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

package/src/elements/EFMedia/audioTasks/makeAudioSeekTask.chunkboundary.regression.browsertest.ts

@@ -1,207 +0,0 @@
-import { afterEach, beforeEach, describe } from "vitest";
-import { test as baseTest } from "../../../../test/useMSW.js";
-import type { EFConfiguration } from "../../../gui/EFConfiguration.js";
-import "../../../gui/EFPreview.js";
-import "../../EFTimegroup.js";
-import type { EFTimegroup } from "../../EFTimegroup.js";
-import "../../EFVideo.js";
-import type { EFVideo } from "../../EFVideo.js";
-
-const test = baseTest.extend<{
-  timegroup: EFTimegroup;
-  video: EFVideo;
-  configuration: EFConfiguration;
-}>({
-  timegroup: async ({}, use) => {
-    const timegroup = document.createElement("ef-timegroup");
-    timegroup.setAttribute("mode", "sequence");
-    timegroup.setAttribute("id", "test-timegroup"); // Required for localStorage key
-    timegroup.style.cssText =
-      "position: relative; height: 500px; width: 1000px; overflow: hidden; background-color: rgb(100 116 139);";
-    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);
-  },
-  video: async ({ configuration, timegroup }, use) => {
-    const video = document.createElement("ef-video");
-    video.id = "bars-n-tone2";
-    video.src = "http://web:3000/head-moov-480p.mp4"; // Real video from working simple-demo
-    video.style.cssText =
-      "width: 100%; height: 100%; object-fit: cover; position: absolute; top: 0; left: 0;";
-
-    // Create the exact structure from simple-demo.html
-    const innerTimegroup = document.createElement("ef-timegroup");
-    innerTimegroup.mode = "contain";
-    innerTimegroup.style.cssText =
-      "position: absolute; width: 100%; height: 100%;";
-    innerTimegroup.append(video);
-    timegroup.append(innerTimegroup);
-    configuration.append(timegroup);
-
-    await use(video);
-  },
-});
-
-/**
- * Regression test for chunk boundary seeking issue
- *
- * Root cause: 32ms coordination gap between PlaybackController and audio track boundaries
- * - PlaybackController seeks to chunk boundary: 4000ms
- * - Audio track actually starts at: 4032ms
- * - Error: "Seek time 4000ms is outside track range [4032ms, 6016ms]"
- *
- * This occurs during active playbook and browser reloads at 4s mark.
- * Fix: Coordinate chunk boundaries or add tolerance for small gaps.
- */
-describe("Audio Seek Task - Chunk Boundary Regression Test", () => {
-  beforeEach(() => {
-    // Clean up DOM and localStorage
-    while (document.body.children.length) {
-      document.body.children[0]?.remove();
-    }
-    localStorage.clear();
-  });
-
-  afterEach(async () => {
-    // Clean up any remaining elements
-    const videos = document.querySelectorAll("ef-video");
-    for (const video of videos) {
-      video.remove();
-    }
-  });
-
-  test.skip("should not throw RangeError when seeking to exact 4000ms during playback", async ({
-    // SKIP: audioSeekTask is not part of the audio rendering pipeline
-    video,
-    timegroup,
-    expect,
-  }) => {
-    await video.mediaEngineTask.taskComplete;
-    await video.audioInputTask.taskComplete;
-
-    // Simulate active playback - start playing from beginning
-    timegroup.currentTimeMs = 0;
-    await video.audioSeekTask.taskComplete;
-
-    // Now seek to the exact problematic time that causes:
-    // "Seek time 4000ms is outside track range [4032ms, 6016ms]"
-    const exactChunkBoundary = 4000;
-    timegroup.currentTimeMs = exactChunkBoundary;
-
-    // Should not throw RangeError due to track range mismatch
-    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
-  });
-
-  test.skip("should not throw RangeError during progressive playback across segments", async ({
-    // SKIP: audioSeekTask is not part of the audio rendering pipeline
-    video,
-    timegroup,
-    expect,
-  }) => {
-    await video.mediaEngineTask.taskComplete;
-    await video.audioInputTask.taskComplete;
-
-    // Simulate progressive playback that loads segments on demand
-    // Start at 3500ms to be just before the 4-second boundary
-    timegroup.currentTimeMs = 3500;
-    await video.audioSeekTask.taskComplete;
-
-    // Now cross the 4-second chunk boundary where track range issues occur
-    // This should trigger the state where track range is [4032ms, 6016ms]
-    // but we're seeking to 4000ms
-    timegroup.currentTimeMs = 4000.000000000001; // The exact error from logs
-
-    // Should not throw "Seek time 4000.000000000001ms is outside track range [4032ms, 6016ms]"
-    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
-  });
-
-  test.skip("should not throw RangeError when localStorage restoration causes 0ms to 4000ms race condition", async ({
-    // SKIP: audioSeekTask is not part of the audio rendering pipeline
-    video,
-    timegroup,
-    expect,
-  }) => {
-    // REPRODUCE THE RACE CONDITION: Simulate localStorage having "4.0"
-    // This mimics the exact simple-demo.html scenario where:
-    // 1. Media loads with assumption of currentTimeMs = 0
-    // 2. localStorage restores currentTime to 4.0 seconds
-    // 3. Seeking 4000ms in segments loaded for 0ms range triggers RangeError
-
-    // Set localStorage BEFORE media finishes initializing
-    if (timegroup.id) {
-      localStorage.setItem(`ef-timegroup-${timegroup.id}`, "4.0");
-    }
-
-    // Wait for media engine but NOT for full initialization
-    await video.mediaEngineTask.taskComplete;
-
-    // Now trigger the localStorage restoration that happens in waitForMediaDurations().then()
-    // This will load currentTime = 4.0 from localStorage, jumping from 0ms to 4000ms
-    const loadedTime = timegroup.loadTimeFromLocalStorage();
-    if (loadedTime !== undefined) {
-      timegroup.currentTime = loadedTime;
-    }
-
-    // This should trigger: "Seek time 4000ms is outside track range [Yms, Zms]"
-    // because segments were loaded for 0ms but we're now seeking 4000ms
-    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
-  });
-
-  test.skip("should not throw RangeError when forced segment coordination mismatch occurs", async ({
-    // SKIP: audioSeekTask is not part of the audio rendering pipeline
-    video,
-    timegroup,
-    expect,
-  }) => {
-    await video.mediaEngineTask.taskComplete;
-
-    // FORCE SPECIFIC SEGMENT LOADING: Load a segment for 8000ms (segment 5)
-    timegroup.currentTimeMs = 8000;
-    await video.audioSegmentIdTask.taskComplete;
-    await video.audioSegmentFetchTask.taskComplete;
-    await video.audioInputTask.taskComplete;
-
-    // Verify we have segment 5 loaded (8000ms / 15000ms = segment 1, but 1-based = segment 1...
-    // Actually 8000ms maps to segment 5 based on the actual segment calculation)
-    const segmentId = video.audioSegmentIdTask.value;
-    expect(segmentId).toBe(4);
-
-    // Now seek to a time in a different segment to test coordination
-    timegroup.currentTimeMs = 4000;
-
-    // This tests the fundamental segment coordination issue:
-    // - We loaded segment 5 for 8000ms
-    // - Now seeking to 4000ms which should be in a different segment
-    // - Tests that seek doesn't fail due to segment boundary coordination
-    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
-  });
-
-  test.skip("should not throw RangeError when rapidly crossing segment boundaries", async ({
-    // SKIP: audioSeekTask is not part of the audio rendering pipeline
-    video,
-    timegroup,
-    expect,
-  }) => {
-    await video.mediaEngineTask.taskComplete;
-
-    // RAPID BOUNDARY CROSSING: This tests timing-sensitive segment coordination
-    const boundaries = [1000, 4000, 8000, 3000, 7000]; // Jump around within segment 1
-
-    for (const timeMs of boundaries) {
-      timegroup.currentTimeMs = timeMs;
-      // Don't await - test rapid succession to trigger coordination issues
-    }
-
-    // Final seek - this should not throw even after rapid boundary crossing
-    timegroup.currentTimeMs = 4000;
-    await expect(video.audioSeekTask.taskComplete).resolves.toBeDefined();
-  });
-});

package/src/elements/EFMedia/audioTasks/makeAudioSeekTask.ts

@@ -1,72 +0,0 @@
-import { Task } from "@lit/task";
-import type { VideoSample } from "mediabunny";
-import { type EFMedia, IgnorableError } from "../../EFMedia";
-import type { BufferedSeekingInput } from "../BufferedSeekingInput";
-
-type AudioSeekTask = Task<
-  readonly [number, BufferedSeekingInput | undefined],
-  VideoSample | undefined
->;
-export const makeAudioSeekTask = (host: EFMedia): AudioSeekTask => {
-  return new Task(host, {
-    args: () => [host.desiredSeekTimeMs, host.audioInputTask.value] as const,
-    onError: (error) => {
-      if (error instanceof IgnorableError) {
-        console.info("audioSeekTask aborted");
-        return;
-      }
-      if (error instanceof DOMException) {
-        console.error(
-          `audioSeekTask error: ${error.message} ${error.name} ${error.code}`,
-        );
-      } else if (error instanceof Error) {
-        console.error(`audioSeekTask error ${error.name}: ${error.message}`);
-      } else {
-        console.error("audioSeekTask unknown error", error);
-      }
-    },
-    onComplete: (_value) => {},
-    task: async (): Promise<VideoSample | undefined> => {
-      return undefined;
-      // TODO: validate that the audio seek task is not actually used to render any audio
-      // CRITICAL FIX: Use the targetSeekTimeMs from args, not host.desiredSeekTimeMs
-      // This ensures we use the same seek time that the segment loading tasks used
-
-      // await host.audioSegmentIdTask.taskComplete;
-      // signal.throwIfAborted(); // Abort if a new seek started
-      // await host.audioSegmentFetchTask.taskComplete;
-      // signal.throwIfAborted(); // Abort if a new seek started
-      // await host.audioInitSegmentFetchTask.taskComplete;
-      // signal.throwIfAborted(); // Abort if a new seek started
-
-      // const audioInput = await host.audioInputTask.taskComplete;
-      // signal.throwIfAborted(); // Abort if a new seek started
-      // if (!audioInput) {
-      //   throw new Error("Audio input is not available");
-      // }
-      // const audioTrack = await audioInput.getFirstAudioTrack();
-      // if (!audioTrack) {
-      //   throw new Error("Audio track is not available");
-      // }
-      // signal.throwIfAborted(); // Abort if a new seek started
-
-      // const sample = (await audioInput.seek(
-      //   audioTrack.id,
-      //   targetSeekTimeMs, // Use the captured value, not host.desiredSeekTimeMs
-      // )) as unknown as VideoSample | undefined;
-      // signal.throwIfAborted(); // Abort if a new seek started
-
-      // // If seek returned undefined, it was aborted - don't throw
-      // if (sample === undefined && signal.aborted) {
-      //   return undefined;
-      // }
-
-      // // If we got undefined but weren't aborted, that's an actual error
-      // if (sample === undefined) {
-      //   throw new Error("Audio seek failed to find sample");
-      // }
-
-      // return sample;
-    },
-  });
-};

package/src/elements/EFMedia/audioTasks/makeAudioSegmentFetchTask.ts

@@ -1,32 +0,0 @@
-import { Task } from "@lit/task";
-import type { MediaEngine } from "../../../transcoding/types";
-import type { EFMedia } from "../../EFMedia";
-import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
-
-export const makeAudioSegmentFetchTask = (
-  host: EFMedia,
-): Task<
-  readonly [MediaEngine | undefined, number | undefined],
-  ArrayBuffer | undefined
-> => {
-  return new Task(host, {
-    args: () =>
-      [host.mediaEngineTask.value, host.audioSegmentIdTask.value] as const,
-    onError: (error) => {
-      console.error("audioSegmentFetchTask error", error);
-    },
-    onComplete: (_value) => {},
-    task: async (_, { signal }) => {
-      const mediaEngine = await getLatestMediaEngine(host, signal);
-      const segmentId = await host.audioSegmentIdTask.taskComplete;
-      const audioRendition = mediaEngine.getAudioRendition();
-
-      // Return undefined if no audio rendition or segment ID available (video-only asset)
-      if (!audioRendition || segmentId === undefined) {
-        return undefined;
-      }
-
-      return mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
-    },
-  });
-};

package/src/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.ts

@@ -1,29 +0,0 @@
-import { Task } from "@lit/task";
-import type { MediaEngine } from "../../../transcoding/types";
-import type { EFMedia } from "../../EFMedia";
-import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
-
-export const makeAudioSegmentIdTask = (
-  host: EFMedia,
-): Task<readonly [MediaEngine | undefined, number], number | undefined> => {
-  return new Task(host, {
-    args: () => [host.mediaEngineTask.value, host.desiredSeekTimeMs] as const,
-    onError: (error) => {
-      console.error("audioSegmentIdTask error", error);
-    },
-    onComplete: (_value) => {},
-    task: async ([, targetSeekTimeMs], { signal }) => {
-      const mediaEngine = await getLatestMediaEngine(host, signal);
-      signal.throwIfAborted();
-
-      const audioRendition = mediaEngine.getAudioRendition();
-
-      // Return undefined if no audio rendition available (video-only asset)
-      if (!audioRendition) {
-        return undefined;
-      }
-
-      return mediaEngine.computeSegmentId(targetSeekTimeMs, audioRendition);
-    },
-  });
-};

package/src/elements/EFMedia/audioTasks/makeAudioTasksVideoOnly.browsertest.ts

@@ -1,95 +0,0 @@
-import { describe } from "vitest";
-import { test as baseTest } from "../../../../test/useMSW.js";
-import type { EFMedia } from "../../EFMedia.js";
-import { AssetMediaEngine } from "../AssetMediaEngine.js";
-
-const test = baseTest.extend<{
-  videoOnlyAssetEngine: AssetMediaEngine;
-}>({
-  videoOnlyAssetEngine: async ({}, use) => {
-    const host = document.createElement("ef-video") as EFMedia;
-    const engine = new AssetMediaEngine(host, "test-video-only.mp4");
-
-    // Simulate video-only asset data (no audio track) - this is the exact scenario
-    // that caused "computeSegmentId: trackId not found for rendition {\"src\":\"uuid\"}"
-    (engine as any).data = {
-      1: {
-        track: 1,
-        type: "video",
-        width: 480,
-        height: 270,
-        timescale: 15360,
-        sample_count: 1,
-        codec: "avc1.640015",
-        duration: 30208,
-        startTimeOffsetMs: 67,
-        initSegment: { offset: 0, size: 763 },
-        segments: [
-          { cts: 1024, dts: 0, duration: 30720, offset: 763, size: 13997 },
-        ],
-      },
-      // Note: No track 2 (audio) - this simulates the exact video-only asset scenario
-    };
-
-    await use(engine);
-  },
-});
-
-/**
- * Regression test for: "computeSegmentId: trackId not found for rendition {\"src\":\"uuid\"}"
- *
- * This test ensures that AssetMediaEngine properly handles video-only assets
- * by returning undefined for audio renditions instead of malformed objects.
- *
- * This test would FAIL with the old implementation and PASS with the new implementation.
- */
-describe("AssetMediaEngine - Video-Only Asset Handling", () => {
-  test("audioRendition returns undefined for video-only asset", ({
-    videoOnlyAssetEngine,
-    expect,
-  }) => {
-    // This is the core fix - should return undefined, not {src: "..."}
-    const audioRendition = videoOnlyAssetEngine.audioRendition;
-    expect(audioRendition).toBeUndefined();
-  });
-
-  test("videoRendition returns valid object for video-only asset", ({
-    videoOnlyAssetEngine,
-    expect,
-  }) => {
-    const videoRendition = videoOnlyAssetEngine.videoRendition;
-    expect(videoRendition).toBeDefined();
-    expect(videoRendition?.trackId).toBe(1);
-    expect(videoRendition?.src).toBe("test-video-only.mp4");
-  });
-
-  test("getAudioRendition returns undefined for video-only asset", ({
-    videoOnlyAssetEngine,
-    expect,
-  }) => {
-    // New API behavior - should return undefined gracefully
-    const result = videoOnlyAssetEngine.getAudioRendition();
-    expect(result).toBeUndefined();
-  });
-
-  test("original error scenario is prevented", ({
-    videoOnlyAssetEngine,
-    expect,
-  }) => {
-    // This is the exact scenario that caused the original error:
-    // "computeSegmentId: trackId not found for rendition {\"src\":\"uuid\"}"
-
-    const audioRendition = videoOnlyAssetEngine.getAudioRendition();
-
-    // Before fix: audioRendition would be {trackId: undefined, src: "..."}
-    // After fix: audioRendition should be undefined
-    expect(audioRendition).toBeUndefined();
-
-    // This prevents the downstream error where trackId was missing entirely
-    if (audioRendition !== undefined) {
-      // If audioRendition exists, it should have a valid trackId
-      expect(audioRendition.trackId).toBeDefined();
-      expect(typeof audioRendition.trackId).toBe("number");
-    }
-  });
-});

package/src/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.ts

@@ -1,184 +0,0 @@
-import { Task } from "@lit/task";
-
-import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
-import { LRUCache } from "../../../utils/LRUCache.js";
-import { type EFMedia, IgnorableError } from "../../EFMedia.js";
-
-// DECAY_WEIGHT constant - same as original
-const DECAY_WEIGHT = 0.8;
-
-export function makeAudioTimeDomainAnalysisTask(element: EFMedia) {
-  // Internal cache for this task instance (same as original #byteTimeDomainCache)
-  const cache = new LRUCache<string, Uint8Array>(1000);
-
-  return new Task(element, {
-    autoRun: EF_INTERACTIVE,
-    onError: (error) => {
-      if (error instanceof IgnorableError) {
-        console.info("byteTimeDomainTask skipped: no audio track");
-        return;
-      }
-      console.error("byteTimeDomainTask error", error);
-    },
-    args: () =>
-      [
-        element.currentSourceTimeMs,
-        element.fftSize,
-        element.fftDecay,
-        element.fftGain,
-        element.shouldInterpolateFrequencies,
-      ] as const,
-    task: async (_, { signal }) => {
-      if (element.currentSourceTimeMs < 0) return null;
-
-      const currentTimeMs = element.currentSourceTimeMs;
-
-      // Calculate exact audio window needed based on fftDecay and frame timing
-      const frameIntervalMs = 1000 / 30; // 33.33ms per frame
-
-      // Need audio from earliest frame to current frame
-      const earliestFrameMs =
-        currentTimeMs - (element.fftDecay - 1) * frameIntervalMs;
-      const fromMs = Math.max(0, earliestFrameMs);
-      const maxToMs = currentTimeMs + frameIntervalMs; // Include current frame
-      const videoDurationMs = element.intrinsicDurationMs || 0;
-      const toMs =
-        videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;
-
-      // If the clamping results in an invalid range (seeking beyond the end), skip analysis silently
-      if (fromMs >= toMs) {
-        return null;
-      }
-
-      // Check cache early - before expensive audio fetching
-      // Use a preliminary cache key that doesn't depend on actual startOffsetMs from audio span
-      const preliminaryCacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${fromMs}:${currentTimeMs}`;
-      const cachedData = cache.get(preliminaryCacheKey);
-      if (cachedData) {
-        return cachedData;
-      }
-
-      const { fetchAudioSpanningTime: fetchAudioSpan } = await import(
-        "../shared/AudioSpanUtils.ts"
-      );
-      const audioSpan = await fetchAudioSpan(element, fromMs, toMs, signal);
-
-      if (!audioSpan || !audioSpan.blob) {
-        console.warn("Time domain analysis skipped: no audio data available");
-        return null;
-      }
-
-      // Decode the real audio data
-      const tempAudioContext = new OfflineAudioContext(2, 48000, 48000);
-      const arrayBuffer = await audioSpan.blob.arrayBuffer();
-      const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);
-
-      // Use actual startOffset from audioSpan (relative to requested time)
-      const startOffsetMs = audioSpan.startMs;
-
-      // Process multiple frames with decay, similar to the reference code
-      const framesData = await Promise.all(
-        Array.from({ length: element.fftDecay }, async (_, frameIndex) => {
-          const frameOffset = frameIndex * (1000 / 30);
-          const startTime = Math.max(
-            0,
-            (currentTimeMs - frameOffset - startOffsetMs) / 1000,
-          );
-
-          const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;
-          const cachedFrame = cache.get(cacheKey);
-          if (cachedFrame) {
-            return cachedFrame;
-          }
-
-          let audioContext: OfflineAudioContext;
-          try {
-            audioContext = new OfflineAudioContext(2, 48000 * (1 / 30), 48000);
-          } catch (error) {
-            throw new Error(
-              `[EFMedia.byteTimeDomainTask] Failed to create OfflineAudioContext(2, ${48000 * (1 / 30)}, 48000) for frame ${frameIndex} at time ${startTime}s: ${error instanceof Error ? error.message : String(error)}. This is for audio time domain analysis.`,
-            );
-          }
-
-          const source = audioContext.createBufferSource();
-          source.buffer = audioBuffer;
-
-          // Create analyzer for PCM data
-          const analyser = audioContext.createAnalyser();
-          analyser.fftSize = element.fftSize; // Ensure enough samples
-          analyser.minDecibels = -90;
-          analyser.maxDecibels = -20;
-
-          const gainNode = audioContext.createGain();
-          gainNode.gain.value = element.fftGain; // Amplify the signal
-
-          source.connect(gainNode);
-          gainNode.connect(analyser);
-          analyser.connect(audioContext.destination);
-
-          source.start(0, startTime, 1 / 30);
-
-          const dataLength = analyser.fftSize / 2;
-          try {
-            await audioContext.startRendering();
-            const frameData = new Uint8Array(dataLength);
-            analyser.getByteTimeDomainData(frameData);
-
-            // const points = frameData;
-            // Calculate RMS and midpoint values
-            const points = new Uint8Array(dataLength);
-            for (let i = 0; i < dataLength; i++) {
-              const pointSamples = frameData.slice(
-                i * (frameData.length / dataLength),
-                (i + 1) * (frameData.length / dataLength),
-              );
-
-              // Calculate RMS while preserving sign
-              const rms = Math.sqrt(
-                pointSamples.reduce((sum, sample) => {
-                  const normalized = (sample - 128) / 128;
-                  return sum + normalized * normalized;
-                }, 0) / pointSamples.length,
-              );
-
-              // Get average sign of the samples to determine direction
-              const avgSign = Math.sign(
-                pointSamples.reduce((sum, sample) => sum + (sample - 128), 0),
-              );
-
-              // Convert RMS back to byte range, preserving direction
-              points[i] = Math.min(255, Math.round(128 + avgSign * rms * 128));
-            }
-
-            cache.set(cacheKey, points);
-            return points;
-          } finally {
-            source.disconnect();
-            analyser.disconnect();
-          }
-        }),
-      );
-
-      // Combine frames with decay weighting
-      const frameLength = framesData[0]?.length ?? 0;
-      const smoothedData = new Uint8Array(frameLength);
-
-      for (let i = 0; i < frameLength; i++) {
-        let weightedSum = 0;
-        let weightSum = 0;
-
-        framesData.forEach((frame: Uint8Array, frameIndex: number) => {
-          const decayWeight = DECAY_WEIGHT ** frameIndex;
-          weightedSum += (frame[i] ?? 0) * decayWeight;
-          weightSum += decayWeight;
-        });
-
-        smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
-      }
-
-      // Cache with the preliminary key so future requests can skip audio fetching
-      cache.set(preliminaryCacheKey, smoothedData);
-      return smoothedData;
-    },
-  });
-}