@editframe/elements 0.26.3-beta.0 → 0.26.4-beta.0

package/src/elements/EFVideo.browsertest.ts

@@ -1,1482 +0,0 @@
-import { html, render } from "lit";
-import { beforeAll, beforeEach, describe, expect, vi } from "vitest";
-
-import { test as baseTest } from "../../test/useMSW.js";
-import type { EFVideo } from "./EFVideo.js";
-import "./EFVideo.js";
-import "../gui/EFWorkbench.js";
-import "../gui/EFPreview.js";
-import "./EFTimegroup.js";
-
-import type { EFTimegroup } from "./EFTimegroup.js";
-
-// Helper to wait for task completion but ignore abort errors
-async function waitForTaskIgnoringAborts(taskPromise: Promise<any>) {
-  try {
-    await taskPromise;
-  } catch (error) {
-    // Ignore AbortError - this is expected when tasks are cancelled due to new seeks
-    if (error instanceof Error && error.name === "AbortError") {
-      return;
-    }
-    throw error;
-  }
-}
-
-beforeAll(async () => {
-  console.clear();
-  await fetch("/@ef-clear-cache", {
-    method: "DELETE",
-  });
-});
-
-beforeEach(() => {
-  localStorage.clear();
-});
-
-// Extend the base test with fixtures following EFMedia.browsertest.ts pattern
-const test = baseTest.extend<{
-  timegroup: EFTimegroup;
-  configuration: any;
-  headMoov480p: EFVideo;
-  barsNtone: EFVideo;
-  barsNtoneTimegroup: EFTimegroup;
-  sequenceTimegroup: EFTimegroup;
-}>({
-  timegroup: async ({}, use) => {
-    const timegroup = document.createElement("ef-timegroup");
-    timegroup.setAttribute("mode", "contain");
-    await use(timegroup);
-  },
-  configuration: async ({}, use) => {
-    const configuration = document.createElement("ef-configuration");
-    const apiHost = "http://localhost:63315";
-    configuration.setAttribute("api-host", apiHost);
-    configuration.apiHost = apiHost;
-    configuration.signingURL = ""; // Disable URL signing for tests
-    document.body.appendChild(configuration);
-    await use(configuration);
-  },
-  headMoov480p: async ({ configuration, timegroup }, use) => {
-    localStorage.removeItem("ef-timegroup-root-this");
-    const host = document.createElement("ef-video");
-    host.src = "http://web:3000/head-moov-480p.mp4";
-    timegroup.append(host);
-    configuration.append(timegroup);
-    await host.mediaEngineTask.run();
-    await use(host);
-  },
-  barsNtone: async ({ barsNtoneTimegroup }, use) => {
-    // The timegroup fixture will have already created the structure
-    const video = barsNtoneTimegroup.querySelector("ef-video") as EFVideo;
-    await video.updateComplete;
-    use(video);
-  },
-  barsNtoneTimegroup: async ({}, use) => {
-    // Clear localStorage to prevent test contamination
-    localStorage.removeItem("ef-timegroup-barsNtoneTimegroup");
-
-    const container = document.createElement("div");
-    render(
-      html`
-      <ef-configuration api-host="http://localhost:63315" signing-url="">
-       <ef-preview>
-         <ef-timegroup mode="sequence" id="barsNtoneTimegroup"
-            class="relative h-[500px] w-[1000px] overflow-hidden bg-slate-500">
-            <ef-video src="bars-n-tone.mp4" id="barsNtoneVideo"></ef-video>
-          </ef-timegroup>
-        </ef-preview>
-      </ef-configuration>
-    `,
-      container,
-    );
-    document.body.appendChild(container);
-    const timegroup = container.querySelector("ef-timegroup") as EFTimegroup;
-    await timegroup.updateComplete;
-    await timegroup.waitForMediaDurations();
-    await use(timegroup);
-    // Cleanup: remove from DOM
-    container.remove();
-  },
-  sequenceTimegroup: async ({}, use) => {
-    const container = document.createElement("div");
-    render(
-      html`
-      <ef-configuration api-host="http://localhost:63315" signing-url="">
-       <ef-preview>
-          <ef-timegroup mode="sequence"
-            class="relative h-[500px] w-[1000px] overflow-hidden bg-slate-500">
-            
-            <ef-timegroup mode="contain" class="absolute w-full h-full">
-              <ef-video src="bars-n-tone.mp4" class="size-full object-fit absolute top-0 left-0"></ef-video>
-            </ef-timegroup>
-            
-            <ef-timegroup mode="contain" class="absolute w-full h-full">
-              <ef-video src="bars-n-tone.mp4" class="size-full object-fit absolute top-0 left-0"></ef-video>
-            </ef-timegroup>
-            
-          </ef-timegroup>
-        </ef-preview>
-      </ef-configuration>
-    `,
-      container,
-    );
-    document.body.appendChild(container);
-    const timegroup = container.querySelector("ef-timegroup") as EFTimegroup;
-    await timegroup.updateComplete;
-    await timegroup.waitForMediaDurations();
-    await use(timegroup);
-    // Cleanup: remove from DOM
-    container.remove();
-  },
-});
-
-describe("EFVideo", () => {
-  describe("basic rendering", () => {
-    beforeEach(async () => {
-      const response = await fetch("/@ef-clear-cache", {
-        method: "DELETE",
-      });
-      await response.text();
-    });
-
-    test("should be defined and render canvas", async ({ expect }) => {
-      const element = document.createElement("ef-video");
-      document.body.appendChild(element);
-
-      // Wait for element to render
-      await element.updateComplete;
-
-      expect(element.tagName).toBe("EF-VIDEO");
-      expect(element.canvasElement).toBeDefined();
-      expect(element.canvasElement?.tagName).toBe("CANVAS");
-    });
-
-    test("canvas has correct default properties", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Wait for element to render
-      await video.updateComplete;
-
-      const canvas = video.canvasElement;
-
-      expect(canvas).toBeDefined();
-      expect(canvas?.width).toBeGreaterThan(0);
-      expect(canvas?.height).toBeGreaterThan(0);
-    });
-
-    test("canvas inherits styling correctly", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(
-        html`
-        <ef-video style="width: 640px; height: 360px;"></ef-video>
-      `,
-        container,
-      );
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Wait for element to render
-      await video.updateComplete;
-
-      const canvas = video.canvasElement;
-
-      expect(canvas).toBeDefined();
-      // Canvas should inherit the styling
-      const computedStyle = window.getComputedStyle(canvas!);
-      expect(computedStyle.width).toBe("640px");
-      expect(computedStyle.height).toBe("360px");
-    });
-  });
-
-  describe("video asset integration", () => {
-    test("integrates with video asset loading", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(
-        html`
-        <ef-preview>
-          <ef-video src="bars-n-tone.mp4" mode="asset"></ef-video>
-        </ef-preview>
-      `,
-        container,
-      );
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      // Wait for media to be ready by waiting for the media engine task to complete
-      await video.mediaEngineTask.taskComplete;
-
-      expect(video.src).toBe("bars-n-tone.mp4");
-
-      // The video should have loaded successfully and have a duration > 0
-      expect(video.intrinsicDurationMs).toBeGreaterThan(0);
-    });
-
-    test("handles missing video asset gracefully", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(
-        html`
-        <ef-preview>
-          <ef-video src="/nonexistent.mp4"></ef-video>
-        </ef-preview>
-      `,
-        container,
-      );
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Should not throw when video asset is missing
-      expect(() => {
-        video.paint(0);
-      }).not.toThrow();
-    });
-  });
-
-  describe("frame painting and canvas updates", () => {
-    test("canvas dimensions update when frame dimensions change", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Wait for element to render
-      await video.updateComplete;
-
-      const canvas = video.canvasElement!;
-
-      // Mock a video frame with specific dimensions
-      const mockFrame = {
-        codedWidth: 1920,
-        codedHeight: 1080,
-        format: "RGBA",
-        timestamp: 0,
-        close: vi.fn(),
-      } as unknown as VideoFrame;
-
-      // Simulate frame painting (this would normally happen through paint method)
-      const ctx = canvas.getContext("2d");
-      if (ctx && mockFrame.codedWidth && mockFrame.codedHeight) {
-        canvas.width = mockFrame.codedWidth;
-        canvas.height = mockFrame.codedHeight;
-        // Mock drawing the frame
-        ctx.fillStyle = "red";
-        ctx.fillRect(0, 0, canvas.width, canvas.height);
-      }
-
-      expect(canvas.width).toBe(1920);
-      expect(canvas.height).toBe(1080);
-    });
-
-    test("handles frame painting with null format gracefully", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Wait for element to render
-      await video.updateComplete;
-
-      const canvas = video.canvasElement!;
-
-      // Mock a frame with null format (edge case)
-      const mockFrame = {
-        codedWidth: 640,
-        codedHeight: 480,
-        format: null,
-        timestamp: 0,
-        close: vi.fn(),
-      } as unknown as VideoFrame;
-
-      const ctx = canvas.getContext("2d");
-
-      // Should handle null format gracefully
-      expect(() => {
-        if (ctx && mockFrame.format === null) {
-          console.warn("Frame format is null", mockFrame);
-          return;
-        }
-      }).not.toThrow();
-    });
-
-    test("canvas context is available for drawing", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Wait for element to render
-      await video.updateComplete;
-
-      const canvas = video.canvasElement!;
-      const ctx = canvas.getContext("2d");
-
-      expect(ctx).toBeDefined();
-      expect(ctx).toBeInstanceOf(CanvasRenderingContext2D);
-
-      // Test that we can draw on the canvas
-      expect(() => {
-        ctx!.fillStyle = "blue";
-        ctx!.fillRect(0, 0, 100, 100);
-      }).not.toThrow();
-    });
-  });
-
-  describe("decoder lock scenarios", () => {
-    test("handles concurrent paint attempts safely", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Access the private decoder lock through reflection for testing
-      const decoderLockDescriptor = Object.getOwnPropertyDescriptor(
-        Object.getPrototypeOf(video),
-        "#decoderLock",
-      );
-
-      // Simulate the decoder being in use
-      if (decoderLockDescriptor) {
-        // We can test that multiple paint calls don't cause issues
-        expect(() => {
-          video.paint(0);
-          video.paint(0);
-          video.paint(0);
-        }).not.toThrow();
-      }
-    });
-
-    test("paint handles missing canvas gracefully", ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Remove canvas to test edge case
-      const canvas = video.canvasElement;
-      canvas?.remove();
-
-      // Paint should handle missing canvas
-      expect(() => video.paint(0)).not.toThrow();
-    });
-
-    test("handles paint with no video asset", ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Paint should handle missing video asset gracefully
-      expect(() => video.paint(0)).not.toThrow();
-    });
-  });
-
-  describe("frame task integration", () => {
-    test("frameTask coordinates all required tasks", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(
-        html`
-        <ef-preview>
-          <ef-video src="/test-video.mp4"></ef-video>
-        </ef-preview>
-      `,
-        container,
-      );
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // frameTask should complete without errors even when other tasks fail
-      expect(() => {
-        video.frameTask.run();
-      }).not.toThrow();
-    });
-
-    test("frameTask handles missing dependencies", ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Should handle missing dependencies gracefully
-      expect(() => {
-        video.frameTask.run();
-      }).not.toThrow();
-    });
-  });
-
-  describe("error handling and edge cases", () => {
-    test("handles seek to invalid time", ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Should handle invalid seek times gracefully
-      expect(() => {
-        video.desiredSeekTimeMs = -1000; // Invalid negative time
-        video.paint(-1000);
-      }).not.toThrow();
-
-      expect(() => {
-        video.desiredSeekTimeMs = Number.POSITIVE_INFINITY;
-        video.paint(Number.POSITIVE_INFINITY);
-      }).not.toThrow();
-    });
-
-    test("handles video element removal during playback", ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Start some operations
-      video.paint(0);
-
-      // Remove element
-      video.remove();
-
-      // Should not cause errors
-      expect(() => {
-        video.paint(0);
-      }).not.toThrow();
-    });
-
-    test("handles canvas context loss gracefully", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      // Wait for element to render
-      await video.updateComplete;
-
-      const canvas = video.canvasElement!;
-
-      // Simulate context loss by making getContext return null
-      const originalGetContext = canvas.getContext;
-      canvas.getContext = vi.fn().mockReturnValue(null);
-
-      // Should handle context loss gracefully
-      expect(() => {
-        video.paint(0);
-      }).not.toThrow();
-
-      // Restore original method
-      canvas.getContext = originalGetContext;
-    });
-  });
-
-  describe("assetId property", () => {
-    test("reads assetId from html source", async ({ expect }) => {
-      const container = document.createElement("div");
-      container.innerHTML = `<ef-video asset-id="test-video-asset-123"></ef-video>`;
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      expect(video).toBeDefined();
-      expect(video.assetId).toBe("test-video-asset-123");
-
-      container.remove();
-    });
-
-    test("reads from js property", ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      video.assetId = "test-video-456";
-      expect(video.assetId).toBe("test-video-456");
-    });
-
-    test("reflects property changes to attribute", async ({ expect }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      video.assetId = "test-video-789";
-      await video.updateComplete;
-      expect(video.getAttribute("asset-id")).toBe("test-video-789");
-
-      video.assetId = null;
-      await video.updateComplete;
-      expect(video.hasAttribute("asset-id")).toBe(false);
-
-      container.remove();
-    });
-  });
-
-  describe("integration with timegroups", () => {
-    test("integrates correctly within timegroup structure", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(
-        html`
-        <ef-preview>
-          <ef-timegroup mode="sequence">
-            <ef-video src="bars-n-tone.mp4" mode="asset"></ef-video>
-          </ef-timegroup>
-        </ef-preview>
-      `,
-        container,
-      );
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      const timegroup = container.querySelector("ef-timegroup");
-      await video.updateComplete;
-
-      // Wait for media to be ready by waiting for the media engine task to complete
-      await video.mediaEngineTask.taskComplete;
-
-      expect(timegroup).toBeDefined();
-
-      // The video should have loaded successfully within the timegroup
-      expect(video.intrinsicDurationMs).toBeGreaterThan(0);
-    });
-
-    test("works as standalone root temporal in ef-preview", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(
-        html`
-        <ef-configuration api-host="http://localhost:63315" signing-url="">
-          <ef-preview id="test-preview">
-            <ef-video src="bars-n-tone.mp4" mode="asset" id="standalone-video"></ef-video>
-          </ef-preview>
-        </ef-configuration>
-      `,
-        container,
-      );
-      document.body.appendChild(container);
-
-      const preview = container.querySelector("ef-preview") as any;
-      const video = container.querySelector("ef-video") as EFVideo;
-
-      await preview.updateComplete;
-      await video.updateComplete;
-
-      // Wait for media to be ready
-      await video.mediaEngineTask.taskComplete;
-
-      // Video should have loaded successfully
-      expect(video.intrinsicDurationMs).toBeGreaterThan(0);
-
-      // Preview should recognize the video as its root temporal
-      expect(preview.targetTemporal).toBe(video);
-
-      // Video should have a playback controller as a root element
-      expect(video.playbackController).toBeDefined();
-
-      // Preview should be able to control playback
-      expect(preview.playing).toBe(false);
-
-      // Seek the video through the preview
-      preview.currentTimeMs = 1000;
-      await video.frameTask.taskComplete;
-
-      // Video should have seeked
-      expect(video.ownCurrentTimeMs).toBeCloseTo(1000, 0);
-
-      // Cleanup
-      container.remove();
-    });
-  });
-
-  describe.skip("loading indicator", () => {
-    test("should not show loading indicator for operations completing under 250ms", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      // Start a fast operation
-      video.startDelayedLoading("test-fast", "Fast operation");
-
-      // Clear it quickly (under 250ms)
-      setTimeout(() => {
-        video.clearDelayedLoading("test-fast");
-      }, 100);
-
-      expect(video.loadingState.isLoading).toBe(false);
-    });
-
-    test("should show loading indicator only after 250ms for slow operations", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      // Start a slow operation
-      video.startDelayedLoading("test-slow", "Slow operation");
-
-      // Should not be loading immediately
-      expect(video.loadingState.isLoading).toBe(false);
-
-      // Should now be loading
-      expect(video.loadingState.isLoading).toBe(true);
-      expect(video.loadingState.message).toBe("Slow operation");
-
-      // Clear the loading
-      video.clearDelayedLoading("test-slow");
-
-      // Should stop loading
-      expect(video.loadingState.isLoading).toBe(false);
-    });
-
-    test("should handle multiple concurrent loading operations", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      // Start multiple operations
-      video.startDelayedLoading("op1", "Operation 1");
-      video.startDelayedLoading("op2", "Operation 2");
-
-      // Should be loading
-      expect(video.loadingState.isLoading).toBe(true);
-
-      // Clear one operation
-      video.clearDelayedLoading("op1");
-
-      // Should still be loading (op2 still active)
-      expect(video.loadingState.isLoading).toBe(true);
-
-      // Clear second operation
-      video.clearDelayedLoading("op2");
-
-      // Should stop loading
-      expect(video.loadingState.isLoading).toBe(false);
-    });
-
-    test("should not show loading for background operations", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      // Start a background operation
-      video.startDelayedLoading("bg-op", "Background operation", {
-        background: true,
-      });
-
-      // Should not show loading UI for background operations
-      expect(video.loadingState.isLoading).toBe(false);
-
-      // Clear the operation
-      video.clearDelayedLoading("bg-op");
-    });
-
-    test("should properly clean up loading state on disconnect", async ({
-      expect,
-    }) => {
-      const container = document.createElement("div");
-      render(html`<ef-video></ef-video>`, container);
-      document.body.appendChild(container);
-
-      const video = container.querySelector("ef-video") as EFVideo;
-      await video.updateComplete;
-
-      // Start an operation
-      video.startDelayedLoading("cleanup-test", "Test operation");
-
-      // Disconnect the element
-      video.remove();
-
-      // Loading should be cleared
-      expect(video.loadingState.isLoading).toBe(false);
-    });
-  });
-
-  describe("AssetMediaEngine", () => {
-    test("seeks to 8074ms", async ({ barsNtone, barsNtoneTimegroup }) => {
-      // Wait for any initial loading to complete
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-
-      // Use timegroup for seeking to ensure audio and video are synchronized
-      barsNtoneTimegroup.currentTimeMs = 8074;
-      await barsNtone.updateComplete;
-
-      // Wait for the new seek tasks to complete (ignoring any aborts from previous operations)
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks to beginning of video (0ms)", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      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.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks to exact segment boundary at 2066ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      // This is approximately where segment 0 ends and segment 1 begins
-      barsNtoneTimegroup.currentTimeMs = 2066;
-      await barsNtone.updateComplete;
-
-      // Wait for the new seek tasks to complete
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks to exact segment boundary at 4033ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      // This is approximately where segment 1 ends and segment 2 begins
-      barsNtoneTimegroup.currentTimeMs = 4033;
-      await barsNtone.updateComplete;
-
-      // Wait for the new seek tasks to complete
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks to exact segment boundary at 6066ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      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.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.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks to exact segment boundary at 8033ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      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.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks to near end of video at 9900ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      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.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks backward from 8000ms to 2000ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-      expect,
-    }) => {
-      await barsNtoneTimegroup.seek(8000);
-      expect(barsNtone.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        8.066,
-      );
-
-      // Then seek backward
-      await barsNtoneTimegroup.seek(2000);
-      expect(barsNtone.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        2.066,
-      );
-    });
-
-    test("seeks to multiple points across segments", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-
-      // Use seek points that are within the actual media duration
-      // Based on the fragment index, the media is about 9.8 seconds long
-      const seekPoints = [1000, 3000, 5000, 7000, 9000];
-
-      for (const seekPoint of seekPoints) {
-        barsNtoneTimegroup.currentTimeMs = seekPoint;
-        await barsNtone.updateComplete;
-        await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-        await waitForTaskIgnoringAborts(
-          barsNtone.unifiedVideoSeekTask.taskComplete,
-        );
-      }
-    });
-
-    test("seeks just before segment boundary at 8030ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      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.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks just after segment boundary at 8070ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      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.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("handles rapid scrubbing between segments", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-
-      // Simulate rapid scrubbing back and forth across segments
-      // Use times that are within the actual media duration
-      const scrubSequence = [
-        0, // Start
-        1000, // Jump to segment 1
-        3000, // Back to segment 0
-        5000, // Forward to segment 2
-        7000, // Back to segment 1
-        9000, // Forward to segment 3
-        0, // Back to segment 0
-        1000, // Jump to segment 1
-      ];
-
-      for (const timeMs of scrubSequence) {
-        // Don't wait for completion between rapid scrubs to simulate the race condition
-        barsNtoneTimegroup.currentTimeMs = timeMs;
-        await barsNtone.updateComplete;
-      }
-
-      // Final seek operations should complete without errors
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("handles concurrent seeks to different segments", async ({
-      expect,
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-
-      // Start multiple seeks without waiting for completion
-      const seekPromises = [];
-
-      // Seek to beginning of segment 0
-      barsNtoneTimegroup.currentTimeMs = 100;
-      await barsNtone.updateComplete;
-      seekPromises.push(
-        Promise.allSettled([
-          barsNtone.audioSeekTask.taskComplete,
-          barsNtone.unifiedVideoSeekTask.taskComplete,
-        ]),
-      );
-
-      // Immediately seek to middle of video (different segment)
-      barsNtoneTimegroup.currentTimeMs = 5000;
-      await barsNtone.updateComplete;
-      seekPromises.push(
-        Promise.allSettled([
-          barsNtone.audioSeekTask.taskComplete,
-          barsNtone.unifiedVideoSeekTask.taskComplete,
-        ]),
-      );
-
-      // Immediately seek to end (within valid range)
-      barsNtoneTimegroup.currentTimeMs = 9000;
-      await barsNtone.updateComplete;
-      seekPromises.push(
-        Promise.allSettled([
-          barsNtone.audioSeekTask.taskComplete,
-          barsNtone.unifiedVideoSeekTask.taskComplete,
-        ]),
-      );
-
-      // Wait for all seeks to complete
-      const results = await Promise.all(seekPromises);
-
-      // At least the final seek should succeed
-      const finalResults = results[results.length - 1];
-      expect(finalResults).toBeDefined();
-      expect(finalResults?.some((r) => r.status === "fulfilled")).toBe(true);
-    });
-
-    test("recovers from segment range errors during scrubbing", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-
-      // Try to reproduce the exact error scenario
-      // First seek to segment 0
-      barsNtoneTimegroup.currentTimeMs = 1000;
-      await barsNtone.updateComplete;
-
-      // Then immediately seek to a time that would be in segment 2
-      // This might cause the range error if segment 0 is still loaded
-      barsNtoneTimegroup.currentTimeMs = 5000; // Safe time within media duration
-      await barsNtone.updateComplete;
-
-      // The system should recover and eventually succeed
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-    });
-
-    test("seeks to 7975ms", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-      expect,
-    }) => {
-      await barsNtoneTimegroup.seek(7975);
-
-      expect(barsNtone.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        8.033,
-      );
-    });
-
-    test("seeks to 8041.667ms in video track 1", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-      expect,
-    }) => {
-      await barsNtoneTimegroup.seekTask.taskComplete;
-      await barsNtoneTimegroup.seek(8041.667);
-      expect(barsNtone.unifiedVideoSeekTask.value?.timestamp).toBe(8.1);
-    });
-
-    test("seeks to 10000ms near end of file", async ({
-      barsNtone,
-      barsNtoneTimegroup,
-    }) => {
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-
-      // Use a safe seek time within the media duration
-      // The original test was trying to seek to 10000ms which is outside the valid range
-      barsNtoneTimegroup.currentTimeMs = 10000;
-      await barsNtone.updateComplete;
-
-      // Should not throw "Sample not found" errors
-      await waitForTaskIgnoringAborts(
-        barsNtone.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-    });
-  });
-
-  describe("JIT Transcoder", () => {
-    test("seeks to start at 0ms", async ({
-      timegroup,
-      headMoov480p,
-      expect,
-    }) => {
-      await waitForTaskIgnoringAborts(
-        headMoov480p.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
-
-      timegroup.currentTimeMs = 0;
-      await timegroup.seekTask.taskComplete;
-
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(0);
-    });
-
-    test("seeks to 1000ms", async ({ timegroup, headMoov480p, expect }) => {
-      await timegroup.seek(1000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(1);
-    });
-
-    test("seeks to 3000ms", async ({ timegroup, headMoov480p, expect }) => {
-      await timegroup.seek(3000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(3);
-    });
-
-    test("seeks to 5000ms", async ({ timegroup, headMoov480p, expect }) => {
-      await timegroup.seek(5000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(5);
-    });
-
-    test("seeks to 7500ms", async ({ timegroup, headMoov480p, expect }) => {
-      await timegroup.seek(7500);
-
-      // JIT transcoding returns actual video frame timestamps, not idealized segment boundaries
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        7.5,
-        1,
-      );
-    });
-
-    test("seeks to 8500ms", async ({ timegroup, headMoov480p, expect }) => {
-      await timegroup.seek(8500);
-
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        8.5,
-        1,
-      );
-    });
-
-    test("seeks to near end at 9000ms", async ({
-      timegroup,
-      headMoov480p,
-      expect,
-    }) => {
-      await timegroup.seek(9000);
-
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(9);
-    });
-
-    test("seeks backward from 7000ms to 2000ms", async ({
-      timegroup,
-      headMoov480p,
-      expect,
-    }) => {
-      await timegroup.seek(7000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(7);
-
-      await timegroup.seek(2000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(2);
-    });
-
-    test("seeks to multiple points in sequence", async ({
-      timegroup,
-      headMoov480p,
-      expect,
-    }) => {
-      const seekPoints = [1000, 3000, 5000, 2000, 6000, 0];
-      const expectedTimestamps = [1, 3, 5, 2, 6, 0];
-
-      for (let i = 0; i < seekPoints.length; i++) {
-        await timegroup.seek(seekPoints[i]!);
-        expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-          expectedTimestamps[i]!,
-          1,
-        );
-      }
-    });
-
-    test("seeks to fractional timestamps", async ({
-      timegroup,
-      headMoov480p,
-      expect,
-    }) => {
-      const fractionalTimes = [1234.567, 3456.789, 5678.901];
-      const expectedTimestamps = [1.234567, 3.456789, 5.678901];
-
-      for (let i = 0; i < fractionalTimes.length; i++) {
-        await timegroup.seek(fractionalTimes[i]!);
-        expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-          expectedTimestamps[i]!,
-          1,
-        );
-      }
-    });
-
-    test("frame tasks are not complete until internal video seek is complete", async ({
-      timegroup,
-      headMoov480p,
-      expect,
-    }) => {
-      await timegroup.seek(0);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        0,
-        1,
-      );
-
-      await timegroup.seek(1000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        1,
-        1,
-      );
-
-      await timegroup.seek(4000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
-        4,
-        1,
-      );
-    });
-
-    test("rapid succession seeks cause intermediate seeks to be skipped", async ({
-      timegroup,
-      headMoov480p,
-      expect,
-    }) => {
-      await timegroup.seek(1000);
-      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(1);
-
-      // // Track frameTask executions using a spy on the run method
-      // const runSpy = vi.spyOn(timegroup.frameTask, 'run');
-
-      // // Rapid succession of seeks - intermediate ones should be skipped
-      // timegroup.currentTimeMs = 1000;
-      // timegroup.currentTimeMs = 2000;
-      // timegroup.currentTimeMs = 3000;
-      // timegroup.currentTimeMs = 4000;
-      // timegroup.currentTimeMs = 1000;
-      // timegroup.currentTimeMs = 2000;
-      // timegroup.currentTimeMs = 3000;
-      // timegroup.currentTimeMs = 8000;
-
-      // await timegroup.seekTask.taskComplete;
-      // expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(8);
-      // expect(runSpy).toHaveBeenCalledTimes(3);
-    });
-  });
-
-  describe("audio analysis tasks with timeline sequences", () => {
-    test("should handle audio analysis when seeking into second video in sequence", async ({
-      sequenceTimegroup,
-    }) => {
-      // Use the sequence fixture which creates two videos in sequence
-      const videos = sequenceTimegroup.querySelectorAll(
-        "ef-video",
-      ) as NodeListOf<EFVideo>;
-      const video1 = videos[0]!;
-      const video2 = videos[1]!;
-
-      // Wait for initial loading
-      await waitForTaskIgnoringAborts(video1.unifiedVideoSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(video1.audioSeekTask.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
-      const firstVideoDuration = video1.intrinsicDurationMs || 10000;
-
-      // Seek into the second video (after the first one ends)
-      const secondVideoSeekTime = firstVideoDuration + 1000;
-      sequenceTimegroup.currentTimeMs = secondVideoSeekTime;
-      await sequenceTimegroup.updateComplete;
-
-      // Both videos should handle the timeline positioning correctly
-      await waitForTaskIgnoringAborts(video1.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(video2.audioSeekTask.taskComplete);
-    });
-
-    test("fixed: JIT transcoding off-by-one bug for exact duration seeks", async ({
-      headMoov480p, // This uses JIT transcoding, not asset transcoding
-    }) => {
-      // This test verifies the fix for the off-by-one bug in JitMediaEngine.computeSegmentId
-      const timegroup = headMoov480p.closest("ef-timegroup") as EFTimegroup;
-
-      // Wait for initial loading to complete
-      await waitForTaskIgnoringAborts(
-        headMoov480p.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
-
-      // The fix: JitMediaEngine.computeSegmentId should handle seeking to exact duration
-      // Before fix: if (desiredSeekTimeMs >= this.durationMs) { return undefined; } ❌
-      // After fix:  if (desiredSeekTimeMs > this.durationMs) { return undefined; } ✅
-
-      // Get the media engine to verify it's JIT transcoding
-      const mediaEngine = headMoov480p.mediaEngineTask.value;
-
-      if (mediaEngine?.constructor.name === "JitMediaEngine") {
-        // Test seeking to exact duration - this should NOT fail with "Segment ID is not available"
-        const exactDuration = headMoov480p.intrinsicDurationMs;
-
-        timegroup.currentTimeMs = exactDuration;
-        await headMoov480p.updateComplete;
-
-        // This should now work without throwing "Segment ID is not available"
-        await waitForTaskIgnoringAborts(
-          headMoov480p.unifiedVideoSeekTask.taskComplete,
-        );
-        await waitForTaskIgnoringAborts(
-          headMoov480p.audioSeekTask.taskComplete,
-        );
-      }
-    });
-
-    test("FIXED: audio analysis tasks handle out-of-bounds time ranges gracefully", async ({
-      headMoov480p,
-    }) => {
-      // This test verifies the fix for "No segments found for time range 10000-15000ms" error
-      const timegroup = headMoov480p.closest("ef-timegroup") as EFTimegroup;
-
-      // Wait for initial loading to complete
-      await waitForTaskIgnoringAborts(
-        headMoov480p.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
-
-      console.log("🧪 TESTING: Audio analysis out-of-bounds time range fix");
-      console.log(`📊 Video duration: ${headMoov480p.intrinsicDurationMs}ms`);
-
-      // Seek to exactly the end of the video to trigger the audio analysis tasks
-      const exactDuration = headMoov480p.intrinsicDurationMs; // Should be 10000ms
-      timegroup.currentTimeMs = exactDuration;
-      await headMoov480p.updateComplete;
-
-      // The fix: audio analysis tasks should now clamp their time ranges to video duration
-      // Before fix: requested "10000-15000ms" → "No segments found" error
-      // After fix:  requested "10000-10000ms" → gracefully skipped or clamped to available range
-
-      console.log(
-        `🎯 EXPECTED FIX: Audio analysis tasks should clamp range to ${exactDuration}-${exactDuration}ms`,
-      );
-      console.log("🎯 Or gracefully skip analysis when seeking beyond end");
-
-      // Let the audio analysis tasks run - they should now handle this gracefully
-
-      // The basic seek should complete without errors
-      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
-      // return null when seeking beyond the end, which is the expected behavior
-    });
-
-    test("FIXED: rapid seeking race condition handled gracefully", async ({
-      expect,
-      headMoov480p,
-    }) => {
-      // This test verifies the fix for race condition where rapid seeks cause
-      // "Seek time Xms is before track start Yms" errors
-      const timegroup = headMoov480p.closest("ef-timegroup") as EFTimegroup;
-
-      // Wait for initial loading to complete
-      await waitForTaskIgnoringAborts(
-        headMoov480p.unifiedVideoSeekTask.taskComplete,
-      );
-      await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
-
-      console.log("🧪 TESTING: Rapid seeking race condition fix");
-      console.log(`📊 Video duration: ${headMoov480p.intrinsicDurationMs}ms`);
-
-      // Simulate rapid seeking that previously caused race conditions
-      // Now should be handled gracefully with warnings instead of errors
-      const rapidSeekSequence = [
-        2000, // Start at 2s
-        7000, // Jump to 7s
-        1000, // Back to 1s (previously caused race condition)
-        8000, // Jump to 8s
-        500, // Back to 0.5s (previously caused race condition)
-        5000, // Jump to 5s
-      ];
-
-      for (const seekTime of rapidSeekSequence) {
-        timegroup.currentTimeMs = seekTime;
-        await headMoov480p.updateComplete;
-      }
-
-      // The fix should prevent errors - both video and audio tasks should complete
-      await waitForTaskIgnoringAborts(
-        headMoov480p.unifiedVideoSeekTask.taskComplete,
-      );
-
-      // Audio tasks should also complete without throwing, though they may log warnings
-      await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
-
-      // Test passes if we reach here without unhandled errors
-      expect(true).toBe(true);
-    });
-  });
-
-  describe("loop attribute", () => {
-    test(
-      "standalone ef-video respects loop attribute",
-      { timeout: 1000 },
-      async () => {
-        const container = document.createElement("div");
-        render(
-          html`
-            <ef-video
-              loop
-              id="loop-video"
-              src="bars-n-tone.mp4"
-              sourceout="2s"
-            ></ef-video>
-          `,
-          container,
-        );
-        document.body.appendChild(container);
-
-        const video = container.querySelector("#loop-video") as EFVideo;
-        await video.updateComplete;
-
-        expect(video.loop).toBe(true);
-        expect(video.playbackController).toBeDefined();
-        expect(video.playbackController?.loop).toBe(true);
-
-        container.remove();
-      },
-    );
-
-    test(
-      "loop property is reactive after initialization",
-      { timeout: 1000 },
-      async () => {
-        const container = document.createElement("div");
-        render(
-          html`
-            <ef-video
-              id="reactive-loop-video"
-              src="bars-n-tone.mp4"
-              sourceout="2s"
-            ></ef-video>
-          `,
-          container,
-        );
-        document.body.appendChild(container);
-
-        const video = container.querySelector(
-          "#reactive-loop-video",
-        ) as EFVideo;
-        await video.updateComplete;
-
-        expect(video.loop).toBe(false);
-        expect(video.playbackController?.loop).toBe(false);
-
-        video.loop = true;
-        await video.updateComplete;
-
-        expect(video.loop).toBe(true);
-        expect(video.playbackController?.loop).toBe(true);
-
-        video.loop = false;
-        await video.updateComplete;
-
-        expect(video.loop).toBe(false);
-        expect(video.playbackController?.loop).toBe(false);
-
-        container.remove();
-      },
-    );
-  });
-});