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

package/src/elements/EFMedia.browsertest.ts

@@ -1,15 +1,37 @@
+import { css } from "lit";
 import { customElement } from "lit/decorators.js";
-import { v4 } from "uuid";
-import { afterEach, beforeEach, describe, expect, test } from "vitest";
-import { EFMedia } from "./EFMedia.js";
-import "../gui/EFWorkbench.js";
+import type { VideoSample } from "mediabunny";
+import { afterEach, beforeEach, describe, vi } from "vitest";
+import { test as baseTest } from "../../test/useMSW.js";
+
+import type { EFConfiguration } from "../gui/EFConfiguration.js";
 import "../gui/EFPreview.js";
+import "../gui/EFWorkbench.js";
+import { JitMediaEngine } from "./EFMedia/JitMediaEngine.js";
+import { EFMedia } from "./EFMedia.js";
 import "./EFTimegroup.js";
-import { assetMSWHandlers } from "../../test/useAssetMSW.js";
-import { useMSW } from "../../test/useMSW.js";
+import type { EFTimegroup } from "./EFTimegroup.js";
+import "./EFVideo.js";
+import { UrlGenerator } from "../transcoding/utils/UrlGenerator.js";
+import type { EFVideo } from "./EFVideo.js";
 
 @customElement("test-media")
-class TestMedia extends EFMedia {}
+class TestMedia extends EFMedia {
+  static styles = [
+    ...EFMedia.styles,
+    css`
+      :host {
+        display: block;
+        width: 100%;
+        height: 100%;
+      }
+      video {
+        width: 100%;
+        height: 100%;
+      }
+  `,
+  ];
+}
 
 declare global {
   interface HTMLElementTagNameMap {
@@ -17,17 +39,145 @@ declare global {
   }
 }
 
-describe("EFMedia", () => {
-  const worker = useMSW();
+const test = baseTest.extend<{
+  timegroup: EFTimegroup;
+  jitVideo: EFVideo;
+  configuration: EFConfiguration;
+  urlGenerator: UrlGenerator;
+  host: EFVideo;
+}>({
+  timegroup: async ({}, use) => {
+    const timegroup = document.createElement("ef-timegroup");
+    timegroup.setAttribute("mode", "contain");
+    await use(timegroup);
+  },
+  configuration: async ({ expect }, use) => {
+    const configuration = document.createElement("ef-configuration");
+    configuration.innerHTML = `<h1 style="font: 10px monospace">${expect.getState().currentTestName}</h1>`;
+    // Use integrated proxy server (same host/port as test runner)
+    const apiHost = `${window.location.protocol}//${window.location.host}`;
+    configuration.setAttribute("api-host", apiHost);
+    configuration.apiHost = apiHost;
+    document.body.appendChild(configuration);
+    await use(configuration);
+    // configuration.remove();
+  },
+  urlGenerator: async ({}, use) => {
+    // UrlGenerator points to integrated proxy server (same host/port as test runner)
+    const apiHost = `${window.location.protocol}//${window.location.host}`;
+    const generator = new UrlGenerator(() => apiHost);
+    await use(generator);
+  },
+  host: async ({ configuration }, use) => {
+    const host = document.createElement("ef-video");
+    configuration.appendChild(host);
+    host.src = "http://web:3000/head-moov-480p.mp4";
+    await use(host);
+  },
+  jitVideo: async ({ configuration, timegroup, host }, use) => {
+    timegroup.append(host);
+    configuration.append(timegroup);
+    await host.mediaEngineTask.run();
+    await use(host);
+  },
+});
+
+describe("JIT Media Engine", () => {
+  test("initializes JitMediaEngine", async ({ jitVideo, expect }) => {
+    const mediaEngine = jitVideo.mediaEngineTask.value;
+    expect(mediaEngine).toBeInstanceOf(JitMediaEngine);
+  });
 
+  test("loads media duration", async ({ jitVideo, expect }) => {
+    expect(jitVideo.intrinsicDurationMs).toBe(10_000);
+  });
+
+  describe("video seek on load", () => {
+    test("seeks to time specified on element", async ({
+      configuration,
+      expect,
+      timegroup,
+    }) => {
+      const element = document.createElement("ef-video");
+      element.src = "http://web:3000/head-moov-480p.mp4";
+      timegroup.append(element);
+      configuration.append(timegroup);
+
+      // Initialize media engine first
+      await element.mediaEngineTask.run();
+      await element.videoSegmentIdTask.run();
+
+      // Then set the time - this should trigger proper synchronization
+      timegroup.currentTimeMs = 2200;
+      element.desiredSeekTimeMs = 2200;
+
+      const sample = await element.videoSeekTask.taskComplete;
+
+      expect(sample).toBeDefined();
+      expect(sample?.timestamp).toEqual(2.2);
+    });
+  });
+
+  describe("video seeking", () => {
+    test("seeks to 0 seconds and loads first frame", async ({
+      timegroup,
+      jitVideo,
+      expect,
+    }) => {
+      timegroup.currentTimeMs = 0;
+      const frame = await (jitVideo as any).videoSeekTask.taskComplete;
+      expect(frame).toBeDefined();
+      expect(frame?.timestamp).toEqual(0);
+    });
+
+    test("seeks to 3 seconds and loads frame", async ({
+      timegroup,
+      jitVideo,
+      expect,
+    }) => {
+      timegroup.currentTimeMs = 3_000;
+      jitVideo.desiredSeekTimeMs = 3_000;
+      const frame = await (jitVideo as any).videoSeekTask.taskComplete;
+      expect(frame).toBeDefined();
+      expect(frame?.timestamp).toEqual(3);
+    });
+
+    test("seeks to 5 seconds and loads frame", async ({
+      timegroup,
+      jitVideo,
+      expect,
+    }) => {
+      timegroup.currentTimeMs = 5_000;
+      jitVideo.desiredSeekTimeMs = 5_000;
+      const frame = await (jitVideo as any).videoSeekTask.taskComplete;
+      expect(frame).toBeDefined();
+      expect(frame?.timestamp).toEqual(5);
+    });
+
+    test("seeks ahead in 50ms increments", async ({
+      timegroup,
+      jitVideo,
+      expect,
+    }) => {
+      timegroup.currentTimeMs = 0;
+      let frame: VideoSample | undefined;
+      for (let i = 0; i <= 3000; i += 50) {
+        timegroup.currentTimeMs = i;
+        jitVideo.desiredSeekTimeMs = i;
+        frame = await (jitVideo as any).videoSeekTask.taskComplete;
+        expect(frame).toBeDefined();
+      }
+      expect(frame?.timestamp).toEqual(3);
+    });
+  });
+});
+
+describe("EFMedia", () => {
   beforeEach(() => {
     // Clean up DOM
     while (document.body.children.length) {
       document.body.children[0]?.remove();
     }
-
-    // Set up MSW handlers to proxy requests to test assets
-    worker.use(...assetMSWHandlers);
   });
 
   afterEach(() => {
@@ -38,325 +188,568 @@ describe("EFMedia", () => {
     }
   });
 
-  test("should be defined", () => {
-    const element = document.createElement("test-media");
+  const test = baseTest.extend<{
+    element: TestMedia;
+  }>({
+    element: async ({}, use) => {
+      const element = document.createElement("test-media");
+      document.body.appendChild(element);
+      await use(element);
+      element.remove();
+    },
+  });
+
+  test("should be defined", ({ element, expect }) => {
     expect(element.tagName).toBe("TEST-MEDIA");
   });
 
-  describe("mode detection", () => {
-    test("should detect JIT mode correctly for external URLs", () => {
-      const element = document.createElement("test-media");
-      element.src = "http://web:3000/tail-moov-1080p.mp4";
-      element.mode = "auto";
+  describe("mute", () => {
+    test("defaults to false", ({ element, expect }) => {
+      expect(element.mute).toBe(false);
+    });
 
-      expect(element.effectiveMode).toBe("jit-transcode");
+    test("reads from js property", ({ element, expect }) => {
+      element.mute = true;
+      expect(element.mute).toBe(true);
     });
 
-    test("should detect asset mode correctly for internal URLs", () => {
-      const element = document.createElement("test-media");
-      element.assetId = "test-asset-123";
-      element.mode = "auto";
+    test("reads from dom attribute", ({ element, expect }) => {
+      element.setAttribute("mute", "true");
+      expect(element.mute).toBe(true);
+    });
 
-      expect(element.effectiveMode).toBe("asset");
+    test("handles any attribute value as true (standard boolean behavior)", ({
+      element,
+      expect,
+    }) => {
+      element.setAttribute("mute", "false");
+      expect(element.mute).toBe(true); // Standard boolean attributes: any value = true
     });
-  });
 
-  describe("JIT audio playback", () => {
-    test.fails(
-      "audioBufferTask should work in JIT mode without URL errors",
-      async () => {
-        const element = document.createElement("test-media");
-        document.body.appendChild(element);
+    test("reflects property changes to attribute", async ({
+      element,
+      expect,
+    }) => {
+      element.mute = true;
+      await element.updateComplete; // Wait for Lit to update
+      expect(element.hasAttribute("mute")).toBe(true);
+      expect(element.getAttribute("mute")).toBe(""); // Standard boolean reflection
+
+      element.mute = false;
+      await element.updateComplete; // Wait for Lit to update
+      expect(element.hasAttribute("mute")).toBe(false); // Standard boolean reflection removes attribute
+    });
 
-        // Set up EFMedia in JIT mode
-        element.src = "http://web:3000/tail-moov-1080p.mp4";
-        element.mode = "jit-transcode";
-        element.currentTimeMs = 1000; // Seek to 1 second
+    describe("audio rendering", () => {
+      // Create a separate test context for audio rendering tests that need configuration
+      const audioTest = baseTest.extend<{
+        timegroup: EFTimegroup;
+        configuration: EFConfiguration;
+      }>({
+        timegroup: async ({}, use) => {
+          const timegroup = document.createElement("ef-timegroup");
+          timegroup.setAttribute("mode", "contain");
+          await use(timegroup);
+        },
+        configuration: async ({ expect }, use) => {
+          const configuration = document.createElement("ef-configuration");
+          configuration.innerHTML = `<h1 style="font: 10px monospace">${expect.getState().currentTestName}</h1>`;
+          // Use integrated proxy server (same host/port as test runner)
+          const apiHost = `${window.location.protocol}//${window.location.host}`;
+          configuration.setAttribute("api-host", apiHost);
+          configuration.apiHost = apiHost;
+          document.body.appendChild(configuration);
+          await use(configuration);
+          // configuration.remove();
+        },
+      });
+
+      audioTest(
+        "skips muted elements during audio rendering",
+        async ({ configuration, timegroup, expect }) => {
+          // Create a muted media element
+          const mutedElement = document.createElement("test-media");
+          mutedElement.src = "http://web:3000/head-moov-480p.mp4";
+          mutedElement.mute = true;
+          timegroup.append(mutedElement);
+
+          // Create an unmuted media element
+          const unmutedElement = document.createElement("test-media");
+          unmutedElement.src = "http://web:3000/head-moov-480p.mp4";
+          unmutedElement.mute = false;
+          timegroup.append(unmutedElement);
+
+          configuration.append(timegroup);
+
+          // Wait for media engines to initialize
+          await mutedElement.mediaEngineTask.run();
+          await unmutedElement.mediaEngineTask.run();
+
+          // Spy on fetchAudioSpanningTime to verify muted element is skipped
+          const mutedFetchSpy = vi.spyOn(
+            mutedElement,
+            "fetchAudioSpanningTime",
+          );
+          const unmutedFetchSpy = vi.spyOn(
+            unmutedElement,
+            "fetchAudioSpanningTime",
+          );
+
+          // Render a short audio segment
+          try {
+            await timegroup.renderAudio(0, 1000); // 1 second
+          } catch (error) {
+            // Audio rendering might fail in test environment, but we're testing the mute logic
+            console.log("Audio rendering failed (expected in test):", error);
+          }
+
+          // Verify muted element was skipped (no fetch calls)
+          expect(mutedFetchSpy).not.toHaveBeenCalled();
+
+          // Verify unmuted element was processed (would have fetch calls if audio succeeds)
+          // Note: In test environment, this might still be 0 due to audio context limitations
+          // but the important thing is that muted element definitely wasn't called
+          const mutedCalls = mutedFetchSpy.mock.calls.length;
+          const unmutedCalls = unmutedFetchSpy.mock.calls.length;
+
+          expect(mutedCalls).toBe(0);
+          // Unmuted element should either be called (audio works) or both fail equally
+          // The key test is that muted=0 and muted < unmuted (if audio works)
+          expect(mutedCalls).toBeLessThanOrEqual(unmutedCalls);
+
+          mutedFetchSpy.mockRestore();
+          unmutedFetchSpy.mockRestore();
+        },
+      );
 
-        // This test should fail because audioBufferTask doesn't handle JIT mode properly
-        // It will try to decode audio from JIT segments which have a different structure
-        await element.audioBufferTask.taskComplete;
+      audioTest(
+        "processes unmuted elements normally",
+        async ({ configuration, timegroup, expect }) => {
+          // Create an unmuted media element
+          const element = document.createElement("test-media");
+          element.src = "http://web:3000/head-moov-480p.mp4";
+          element.mute = false;
+          timegroup.append(element);
 
-        const audioBuffer = element.audioBufferTask.value;
-        expect(audioBuffer).toBeDefined();
-        expect(audioBuffer?.buffer).toBeDefined();
-        expect(audioBuffer?.startOffsetMs).toBeGreaterThanOrEqual(0);
-      },
-    );
+          configuration.append(timegroup);
 
-    test.skip("fetchAudioSpanningTime should work in JIT mode without URL errors", async () => {
-      const element = document.createElement("test-media");
-      document.body.appendChild(element);
+          await element.mediaEngineTask.run();
 
-      // Set up EFMedia in JIT mode
-      element.src = "http://web:3000/tail-moov-1080p.mp4";
-      element.mode = "jit-transcode";
+          const fetchSpy = vi.spyOn(element, "fetchAudioSpanningTime");
 
-      // Wait for JIT metadata to load first
-      await element.jitMetadataLoader.taskComplete;
+          try {
+            await timegroup.renderAudio(0, 1000);
+          } catch (error) {
+            // Audio rendering might fail in test environment
+            console.log("Audio rendering failed (expected in test):", error);
+          }
 
-      // Wait for fragment index to be created from JIT metadata
-      await element.fragmentIndexTask.taskComplete;
+          // The element should not have been skipped due to mute
+          // (whether it actually gets called depends on test environment audio support)
+          expect(element.mute).toBe(false);
 
-      // This test now passes because the bug has been fixed
-      const audioData = await element.fetchAudioSpanningTime(0, 2000);
+          fetchSpy.mockRestore();
+        },
+      );
 
-      // If we get here without an error, the bug is fixed
-      expect(audioData).toBeDefined();
-      expect(audioData?.blob).toBeDefined();
-      expect(audioData?.startMs).toBeGreaterThanOrEqual(0);
-      expect(audioData?.endMs).toBeGreaterThan(audioData!.startMs);
-    });
+      audioTest(
+        "handles dynamic mute changes",
+        async ({ configuration, timegroup, expect }) => {
+          const element = document.createElement("test-media");
+          element.src = "http://web:3000/head-moov-480p.mp4";
+          element.mute = false; // Start unmuted
+          timegroup.append(element);
 
-    test("should handle audio properly in asset mode (baseline)", async () => {
-      const element = document.createElement("test-media");
-      const preview = document.createElement("ef-preview");
-      preview.appendChild(element);
-      document.body.appendChild(preview);
+          configuration.append(timegroup);
 
-      // Set up EFMedia in asset mode
-      element.assetId = "test-asset-123";
-      element.mode = "asset";
-      element.src = "/test-assets/media/bars-n-tone2.mp4";
-
-      // Wait for fragment index to load
-      await new Promise((resolve) => setTimeout(resolve, 300));
-
-      // Asset mode should work fine (this is our baseline)
-      try {
-        const audioData = await element.fetchAudioSpanningTime(0, 2000);
-        expect(audioData).toBeDefined();
-      } catch (error) {
-        // Audio data might not be available in test environment, but should not throw URL errors
-        expect(String(error)).not.toMatch(/URL/);
-      }
-    });
-  });
+          await element.mediaEngineTask.run();
 
-  describe("when rendering", () => {
-    beforeEach(() => {
-      // @ts-expect-error
-      window.FRAMEGEN_BRIDGE = true;
-    });
-    afterEach(() => {
-      delete window.FRAMEGEN_BRIDGE;
-    });
+          const fetchSpy = vi.spyOn(element, "fetchAudioSpanningTime");
 
-    test("fragmentIndexPath uses http:// protocol", () => {
-      const workbench = document.createElement("ef-workbench");
-      const element = document.createElement("test-media");
-      workbench.appendChild(element);
-      element.assetId = "550e8400-e29b-41d4-a716-446655440000:example.mp4";
-      expect(element.fragmentIndexPath()).toBe(
-        "https://editframe.dev/api/v1/isobmff_files/550e8400-e29b-41d4-a716-446655440000:example.mp4/index",
-      );
-    });
+          // First render - unmuted
+          try {
+            await timegroup.renderAudio(0, 500);
+          } catch (error) {
+            console.log("Audio rendering failed (expected in test):", error);
+          }
 
-    test("fragmentTrackPath uses http:// protocol", () => {
-      const workbench = document.createElement("ef-workbench");
-      const element = document.createElement("test-media");
-      workbench.appendChild(element);
-      element.assetId = "550e8400-e29b-41d4-a716-446655440000:example.mp4";
-      expect(element.fragmentTrackPath("1")).toBe(
-        "https://editframe.dev/api/v1/isobmff_tracks/550e8400-e29b-41d4-a716-446655440000:example.mp4/1",
-      );
-    });
-  });
+          const firstCallCount = fetchSpy.mock.calls.length;
 
-  describe("attribute: asset-id", () => {
-    test("determines fragmentIndexPath", () => {
-      const id = v4();
-      const element = document.createElement("test-media");
-      element.setAttribute("asset-id", id);
-      expect(element.fragmentIndexPath()).toBe(
-        `https://editframe.dev/api/v1/isobmff_files/${id}/index`,
-      );
-    });
+          // Mute the element
+          element.mute = true;
+          await element.updateComplete;
 
-    test("determines fragmentTrackPath", () => {
-      const id = v4();
-      const element = document.createElement("test-media");
-      element.setAttribute("asset-id", id);
-      expect(element.fragmentTrackPath("1")).toBe(
-        `https://editframe.dev/api/v1/isobmff_tracks/${id}/1`,
-      );
-    });
+          // Second render - muted (should be skipped)
+          try {
+            await timegroup.renderAudio(500, 1000);
+          } catch (error) {
+            console.log("Audio rendering failed (expected in test):", error);
+          }
 
-    test("honors apiHost in fragmentIndexPath", () => {
-      const id = v4();
-      const element = document.createElement("test-media");
-      element.setAttribute("asset-id", id);
-      const preview = document.createElement("ef-preview");
-      preview.appendChild(element);
-      preview.apiHost = "test://";
-      document.body.appendChild(preview);
-      expect(element.fragmentIndexPath()).toBe(
-        `test:///api/v1/isobmff_files/${id}/index`,
-      );
-    });
+          const secondCallCount = fetchSpy.mock.calls.length;
 
-    test("honors apiHost in fragmentTrackPath", () => {
-      const id = v4();
-      const element = document.createElement("test-media");
-      element.setAttribute("asset-id", id);
-      const preview = document.createElement("ef-preview");
-      preview.appendChild(element);
-      preview.apiHost = "test://";
-      document.body.appendChild(preview);
-      expect(element.fragmentTrackPath("1")).toBe(
-        `test:///api/v1/isobmff_tracks/${id}/1`,
+          // Verify no additional calls were made when muted
+          expect(secondCallCount).toBe(firstCallCount);
+
+          fetchSpy.mockRestore();
+        },
       );
     });
   });
 
-  describe("calculating duration", () => {
-    test("Computes duration from track fragment index", async () => {
-      const element = document.createElement("test-media");
-      element.src = "/test-assets/media/bars-n-tone2.mp4";
-      element.mode = "asset";
-
-      const preview = document.createElement("ef-preview");
-      preview.appendChild(element);
-      document.body.appendChild(preview);
-
-      // Wait for fragment index to load
-      await new Promise((resolve) => setTimeout(resolve, 300));
-
-      // The media should have loaded successfully and have a duration > 0
-      // We don't test for specific duration since real assets may vary
-      expect(element.intrinsicDurationMs).toBeGreaterThan(0);
-      expect(element.durationMs).toBeGreaterThan(0);
+  describe("audio analysis", () => {
+    const audioAnalysisTest = baseTest.extend<{
+      timegroup: EFTimegroup;
+      configuration: EFConfiguration;
+    }>({
+      timegroup: async ({}, use) => {
+        const timegroup = document.createElement("ef-timegroup");
+        timegroup.setAttribute("mode", "contain");
+        await use(timegroup);
+      },
+      configuration: async ({ expect }, use) => {
+        const configuration = document.createElement("ef-configuration");
+        configuration.innerHTML = `<h1 style="font: 10px monospace">${expect.getState().currentTestName}</h1>`;
+        // Use integrated proxy server (same host/port as test runner)
+        const apiHost = `${window.location.protocol}//${window.location.host}`;
+        configuration.setAttribute("api-host", apiHost);
+        configuration.apiHost = apiHost;
+        document.body.appendChild(configuration);
+        await use(configuration);
+      },
     });
 
-    test("Computes duration from track fragment index sourcein", async () => {
-      const timegroup = document.createElement("ef-timegroup");
-      timegroup.mode = "sequence";
-      const element = document.createElement("test-media");
-      element.src = "/assets/10s-bars.mp4";
-      element.sourceInMs = 1_000;
+    audioAnalysisTest(
+      "has time domain analysis task",
+      async ({ configuration, timegroup, expect }) => {
+        const element = document.createElement("test-media");
+        element.src = "http://web:3000/head-moov-480p.mp4";
+        timegroup.append(element);
+        configuration.append(timegroup);
 
-      const preview = document.createElement("ef-preview");
-      timegroup.appendChild(element);
-      preview.appendChild(timegroup);
-      document.body.appendChild(preview);
+        await element.mediaEngineTask.run();
 
-      // Await the next tick to ensure the element has a chance to load the track fragment
-      await Promise.resolve();
+        expect(element.byteTimeDomainTask).toBeDefined();
+        expect(typeof element.byteTimeDomainTask.taskComplete).toBe("object");
+      },
+    );
 
-      await element.fragmentIndexTask.taskComplete;
+    audioAnalysisTest(
+      "has frequency analysis task",
+      async ({ configuration, timegroup, expect }) => {
+        const element = document.createElement("test-media");
+        element.src = "http://web:3000/head-moov-480p.mp4";
+        timegroup.append(element);
+        configuration.append(timegroup);
 
-      // Use tolerance for real asset durations (should be close to expected)
-      expect(element.durationMs).toBeGreaterThan(8500);
-      expect(element.durationMs).toBeLessThan(9500);
-      expect(timegroup.durationMs).toBeGreaterThan(8500);
-      expect(timegroup.durationMs).toBeLessThan(9500);
-    });
+        await element.mediaEngineTask.run();
 
-    test("Computes duration from track fragment index sourcein", async () => {
-      const timegroup = document.createElement("ef-timegroup");
-      timegroup.mode = "sequence";
-      const element = document.createElement("test-media");
-      element.src = "/assets/10s-bars.mp4";
-      element.sourceInMs = 6_000;
+        expect(element.frequencyDataTask).toBeDefined();
+        expect(typeof element.frequencyDataTask.taskComplete).toBe("object");
+      },
+    );
 
-      const preview = document.createElement("ef-preview");
-      timegroup.appendChild(element);
-      preview.appendChild(timegroup);
-      document.body.appendChild(preview);
+    audioAnalysisTest(
+      "respects FFT configuration properties",
+      async ({ configuration, timegroup, expect }) => {
+        const element = document.createElement("test-media");
+        element.src = "http://web:3000/head-moov-480p.mp4";
+        element.fftSize = 256;
+        element.fftDecay = 4;
+        element.fftGain = 2.0;
+        element.interpolateFrequencies = true;
+        timegroup.append(element);
+        configuration.append(timegroup);
+
+        await element.mediaEngineTask.run();
+
+        expect(element.fftSize).toBe(256);
+        expect(element.fftDecay).toBe(4);
+        expect(element.fftGain).toBe(2.0);
+        expect(element.interpolateFrequencies).toBe(true);
+        expect(element.shouldInterpolateFrequencies).toBe(true);
+      },
+    );
 
-      // Await the next tick to ensure the element has a chance to load the track fragment
-      await Promise.resolve();
+    audioAnalysisTest(
+      "generates FREQ_WEIGHTS based on fftSize",
+      async ({ configuration, timegroup, expect }) => {
+        const element = document.createElement("test-media");
+        element.src = "http://web:3000/head-moov-480p.mp4";
+        element.fftSize = 128;
+        timegroup.append(element);
+        configuration.append(timegroup);
+
+        await element.mediaEngineTask.run();
+
+        const weights = element.FREQ_WEIGHTS;
+        expect(weights).toBeInstanceOf(Float32Array);
+        expect(weights.length).toBe(element.fftSize / 2); // 64 for fftSize 128
+
+        // Test frequency weighting - lower frequencies should have lower weights
+        expect(weights.length).toBeGreaterThan(0);
+        const firstWeight = weights[0];
+        const lastWeight = weights[weights.length - 1];
+        expect(firstWeight).toBeDefined();
+        expect(lastWeight).toBeDefined();
+        expect(firstWeight!).toBeLessThan(lastWeight!);
+      },
+    );
+  });
 
-      await element.fragmentIndexTask.taskComplete;
+  describe("assetId", () => {
+    test("reads from js property", ({ element, expect }) => {
+      element.assetId = "test-asset-123";
+      expect(element.assetId).toBe("test-asset-123");
+    });
 
-      expect(element.durationMs).toBeCloseTo(4085, 0);
-      expect(timegroup.durationMs).toBeCloseTo(4085, 0);
+    test("reads from dom attribute", ({ element, expect }) => {
+      element.setAttribute("asset-id", "test-asset-123");
+      expect(element.assetId).toBe("test-asset-123");
     });
 
-    test("Computes duration from track fragment index sourceout", async () => {
-      const timegroup = document.createElement("ef-timegroup");
-      timegroup.mode = "sequence";
-      const element = document.createElement("test-media");
-      element.src = "/assets/10s-bars.mp4";
-      element.sourceOutMs = 6_000;
+    test("defaults to null", ({ element, expect }) => {
+      expect(element.assetId).toBe(null);
+    });
 
-      const preview = document.createElement("ef-preview");
-      timegroup.appendChild(element);
-      preview.appendChild(timegroup);
-      document.body.appendChild(preview);
+    test("reflects property changes to attribute", async ({
+      element,
+      expect,
+    }) => {
+      element.assetId = "test-asset-456";
+      await element.updateComplete;
+      expect(element.getAttribute("asset-id")).toBe("test-asset-456");
+
+      element.assetId = null;
+      await element.updateComplete;
+      expect(element.hasAttribute("asset-id")).toBe(false);
+    });
 
-      // Await the next tick to ensure the element has a chance to load the track fragment
-      await Promise.resolve();
+    test("reads assetId from html source", async ({ expect }) => {
+      const container = document.createElement("div");
+      container.innerHTML = `<test-media asset-id="test-asset-789"></test-media>`;
+      const media = container.querySelector("test-media") as TestMedia;
+      expect(media).toBeDefined();
+      expect(media.assetId).toBe("test-asset-789");
+    });
+  });
 
-      await element.fragmentIndexTask.taskComplete;
+  describe("fftSize", () => {
+    test("defaults to 128", ({ element, expect }) => {
+      expect(element.fftSize).toBe(128);
+    });
 
-      expect(element.durationMs).toBeCloseTo(6_000, 0);
-      expect(timegroup.durationMs).toBeCloseTo(6_000, 0);
+    test("reads from js property", ({ element, expect }) => {
+      element.fftSize = 1024;
+      expect(element.fftSize).toBe(1024);
     });
 
-    test("Computes duration from track fragment index sourceout", async () => {
-      const timegroup = document.createElement("ef-timegroup");
-      timegroup.mode = "sequence";
-      const element = document.createElement("test-media");
-      element.src = "/assets/10s-bars.mp4";
-      element.sourceOutMs = 5_000;
+    test("reads from dom attribute", ({ element, expect }) => {
+      element.setAttribute("fft-size", "1024");
+      expect(element.fftSize).toBe(1024);
+    });
 
-      const preview = document.createElement("ef-preview");
-      timegroup.appendChild(element);
-      preview.appendChild(timegroup);
-      document.body.appendChild(preview);
+    test("reflects property changes to attribute", async ({
+      element,
+      expect,
+    }) => {
+      element.fftSize = 512;
+      await element.updateComplete;
+      expect(element.getAttribute("fft-size")).toBe("512");
+    });
+  });
 
-      // Await the next tick to ensure the element has a chance to load the track fragment
-      await Promise.resolve();
+  describe("fftDecay", () => {
+    test("defaults to 8", ({ element, expect }) => {
+      expect(element.fftDecay).toBe(8);
+    });
 
-      await element.fragmentIndexTask.taskComplete;
+    test("reads from js property", ({ element, expect }) => {
+      element.fftDecay = 16;
+      expect(element.fftDecay).toBe(16);
+    });
 
-      expect(element.durationMs).toBeCloseTo(5_000, 0);
-      expect(timegroup.durationMs).toBeCloseTo(5_000, 0);
+    test("reads from dom attribute", ({ element, expect }) => {
+      element.setAttribute("fft-decay", "16");
+      expect(element.fftDecay).toBe(16);
     });
 
-    test("Computes duration from track fragment index sourceout and sourcein", async () => {
-      const timegroup = document.createElement("ef-timegroup");
-      timegroup.mode = "sequence";
-      const element = document.createElement("test-media");
-      element.src = "/assets/10s-bars.mp4";
-      element.sourceInMs = 1_000;
-      element.sourceOutMs = 5_000;
+    test("reflects property changes to attribute", async ({
+      element,
+      expect,
+    }) => {
+      element.fftDecay = 32;
+      await element.updateComplete;
+      expect(element.getAttribute("fft-decay")).toBe("32");
+    });
+  });
 
-      const preview = document.createElement("ef-preview");
-      timegroup.appendChild(element);
-      preview.appendChild(timegroup);
-      document.body.appendChild(preview);
+  describe("fftGain", () => {
+    test("defaults to 3.0", ({ element, expect }) => {
+      expect(element.fftGain).toBe(3.0);
+    });
 
-      // Await the next tick to ensure the element has a chance to load the track fragment
-      await Promise.resolve();
+    test("reads from js property", ({ element, expect }) => {
+      element.fftGain = 0.5;
+      expect(element.fftGain).toBe(0.5);
+    });
 
-      await element.fragmentIndexTask.taskComplete;
+    test("reads from dom attribute", ({ element, expect }) => {
+      element.setAttribute("fft-gain", "0.5");
+      expect(element.fftGain).toBe(0.5);
+    });
 
-      expect(element.durationMs).toBeCloseTo(4_000, 0);
-      expect(timegroup.durationMs).toBeCloseTo(4_000, 0);
+    test("reflects property changes to attribute", async ({
+      element,
+      expect,
+    }) => {
+      element.fftGain = 2.5;
+      await element.updateComplete;
+      expect(element.getAttribute("fft-gain")).toBe("2.5");
     });
+  });
 
-    test("Computes duration from track fragment index sourceout and sourcein", async () => {
-      const timegroup = document.createElement("ef-timegroup");
-      timegroup.mode = "sequence";
-      const element = document.createElement("test-media");
-      element.src = "/assets/10s-bars.mp4";
-      element.sourceInMs = 9_000;
-      element.sourceOutMs = 10_000;
+  describe("interpolateFrequencies", () => {
+    test("defaults to false", ({ element, expect }) => {
+      expect(element.interpolateFrequencies).toBe(false);
+    });
 
-      const preview = document.createElement("ef-preview");
-      timegroup.appendChild(element);
-      preview.appendChild(timegroup);
-      document.body.appendChild(preview);
+    test("reads from js property", ({ element, expect }) => {
+      element.interpolateFrequencies = true;
+      expect(element.interpolateFrequencies).toBe(true);
+    });
 
-      // Await the next tick to ensure the element has a chance to load the track fragment
-      await Promise.resolve();
+    test("reads from dom attribute", ({ element, expect }) => {
+      element.setAttribute("interpolate-frequencies", "true");
+      expect(element.interpolateFrequencies).toBe(true);
+    });
 
-      await element.fragmentIndexTask.taskComplete;
+    test("handles any attribute value as true (standard boolean behavior)", ({
+      element,
+      expect,
+    }) => {
+      element.setAttribute("interpolate-frequencies", "false");
+      expect(element.interpolateFrequencies).toBe(true); // Standard boolean attributes: any value = true
+    });
 
-      expect(element.durationMs).toBeCloseTo(1_000, 0);
-      expect(timegroup.durationMs).toBeCloseTo(1_000, 0);
+    test("reflects property changes to attribute", async ({
+      element,
+      expect,
+    }) => {
+      element.interpolateFrequencies = true;
+      await element.updateComplete;
+      expect(element.hasAttribute("interpolate-frequencies")).toBe(true);
+      expect(element.getAttribute("interpolate-frequencies")).toBe(""); // Standard boolean reflection
+
+      element.interpolateFrequencies = false;
+      await element.updateComplete;
+      expect(element.hasAttribute("interpolate-frequencies")).toBe(false); // Standard boolean reflection removes attribute
     });
   });
+
+  //   describe("mediaEngineTask", () => {
+  //     test("is defined", ({ element, expect }) => {
+  //       expect(element.mediaEngineTask).toBeDefined();
+  //     });
+
+  //     test("is a task", ({ element, expect }) => {
+  //       expect(element.mediaEngineTask).toBeInstanceOf(Task);
+  //     });
+
+  //     test("throws if assetId is set", async ({ element, expect }) => {
+  //       element.assetId = "test-asset-123";
+  //       await element.mediaEngineTask.run();
+  //       expect(element.mediaEngineTask.error).toBeInstanceOf(Error);
+  //     });
+
+  //     test("creates JitMediaEngine for http sources", async ({
+  //       elementWithJitManifest,
+  //       expect,
+  //       worker,
+  //     }) => {
+  //       await elementWithJitManifest.mediaEngineTask.run();
+  //       expect(elementWithJitManifest.mediaEngineTask.value).toBeInstanceOf(
+  //         JitMediaEngine,
+  //       );
+  //     });
+
+  //     test("creates AssetMediaEngine for local sources", async ({
+  //       elementWithAsset,
+  //       expect,
+  //     }) => {
+  //       await elementWithAsset.mediaEngineTask.run();
+  //       expect(elementWithAsset.mediaEngineTask.value).toBeInstanceOf(
+  //         AssetMediaEngine,
+  //       );
+  //     });
+  //   });
+
+  //   describe("Video Buffering Integration", () => {
+  //     test("videoBufferTask is available and configured", ({
+  //       element,
+  //       expect,
+  //     }) => {
+  //       expect(element.videoBufferTask).toBeDefined();
+  //       expect(element.videoBufferDurationMs).toBe(60000); // 60 seconds default
+  //       expect(element.maxVideoBufferFetches).toBe(2); // 2 parallel fetches default
+  //       expect(element.enableVideoBuffering).toBe(true); // enabled by default
+  //     });
+
+  //     test("buffer configuration can be customized", ({ element, expect }) => {
+  //       element.videoBufferDurationMs = 45000;
+  //       element.maxVideoBufferFetches = 3;
+  //       element.enableVideoBuffering = false;
+
+  //       expect(element.videoBufferDurationMs).toBe(45000);
+  //       expect(element.maxVideoBufferFetches).toBe(3);
+  //       expect(element.enableVideoBuffering).toBe(false);
+  //     });
+
+  //     test("buffer task starts automatically with JIT asset", async ({
+  //       elementWithJitManifest,
+  //       expect,
+  //     }) => {
+  //       const element = elementWithJitManifest;
+
+  //       // Wait for media engine to initialize
+  //       await element.mediaEngineTask.taskComplete;
+
+  //       // Buffer task should be available and have started
+  //       expect(element.videoBufferTask).toBeDefined();
+  //       // Task status should be INITIAL (0) or higher, indicating it's been created
+  //       expect(element.videoBufferTask.status).toBeGreaterThanOrEqual(0);
+  //     });
+  //   });
+  // });
+
+  // // Test to verify buffer tasks use EFMedia properties directly (no hardcoded config duplication)
+  // describe("Buffer Task Property Integration", () => {
+  //   test("audio and video buffer tasks use EFMedia properties directly", async ({
+  //     element,
+  //     expect,
+  //   }) => {
+  //     // Set custom buffer configuration on the element
+  //     element.audioBufferDurationMs = 15000;
+  //     element.maxAudioBufferFetches = 3;
+  //     element.enableAudioBuffering = false;
+
+  //     element.videoBufferDurationMs = 45000;
+  //     element.maxVideoBufferFetches = 5;
+  //     element.enableVideoBuffering = false;
+
+  //     // Verify the tasks are created without requiring hardcoded config
+  //     expect(element.audioBufferTask).toBeDefined();
+  //     expect(element.videoBufferTask).toBeDefined();
+
+  //     // The task configuration should now come directly from element properties
+  //     // This test ensures no hardcoded config duplication exists
+  //     expect(element.audioBufferDurationMs).toBe(15000);
+  //     expect(element.maxAudioBufferFetches).toBe(3);
+  //     expect(element.enableAudioBuffering).toBe(false);
+
+  //     expect(element.videoBufferDurationMs).toBe(45000);
+  //     expect(element.maxVideoBufferFetches).toBe(5);
+  //     expect(element.enableVideoBuffering).toBe(false);
+  //   });
+  // });
 });