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

package/src/elements/EFMedia/BufferedSeekingInput.ts

@@ -6,13 +6,14 @@ import {
   VideoSampleSink,
 } from "mediabunny";
 import { type MediaSample, SampleBuffer } from "../SampleBuffer";
+import { roundToMilliseconds } from "./shared/PrecisionUtils";
 
 interface BufferedSeekingInputOptions {
   videoBufferSize?: number;
   audioBufferSize?: number;
   /**
-   * FFmpeg start_time offset in milliseconds from the processed video.
-   * Applied during seeking to correct for timing shifts introduced by FFmpeg processing.
+   * Timeline offset in milliseconds to map user timeline to media timeline.
+   * Applied during seeking to handle media that doesn't start at 0ms.
    */
   startTimeOffsetMs?: number;
 }
@@ -35,8 +36,8 @@ export class BufferedSeekingInput {
   private trackSeekPromises: Map<number, Promise<any>> = new Map();
 
   /**
-   * FFmpeg start_time offset in milliseconds from the processed video.
-   * Applied during seeking to correct for timing shifts introduced by FFmpeg processing.
+   * Timeline offset in milliseconds to map user timeline to media timeline.
+   * Applied during seeking to handle media that doesn't start at 0ms.
    */
   private readonly startTimeOffsetMs: number;
 
@@ -178,8 +179,11 @@ export class BufferedSeekingInput {
   }
 
   async seek(trackId: number, timeMs: number) {
-    // Apply the start time offset to deal with files that don't start on the zero
-    const correctedTimeMs = timeMs + this.startTimeOffsetMs;
+    // Apply timeline offset to map user timeline to media timeline
+    const mediaTimeMs = timeMs + this.startTimeOffsetMs;
+
+    // Round using consistent precision handling
+    const roundedMediaTimeMs = roundToMilliseconds(mediaTimeMs);
 
     // Serialize seek operations per track (but don't block iterator creation)
     const existingSeek = this.trackSeekPromises.get(trackId);
@@ -187,7 +191,7 @@ export class BufferedSeekingInput {
       await existingSeek;
     }
 
-    const seekPromise = this.seekSafe(trackId, correctedTimeMs);
+    const seekPromise = this.seekSafe(trackId, roundedMediaTimeMs);
     this.trackSeekPromises.set(trackId, seekPromise);
 
     try {
@@ -226,23 +230,60 @@ export class BufferedSeekingInput {
     // biome-ignore lint/style/noNonNullAssertion: we know the map has the key
     const trackBuffer = this.trackBuffers.get(trackId)!;
 
-    if (timeMs < trackBuffer.firstTimestamp * 1000) {
-      await this.resetIterator(trackId);
-    }
-
-    const alreadyInBuffer = trackBuffer.find(timeMs);
     const track = await this.getTrack(trackId);
 
     // Early validation: check if seek time is outside track bounds
-    const firstTimestampMs = (await track.getFirstTimestamp()) * 1000;
-    const lastSampleEndMs = (await track.computeDuration()) * 1000; // computeDuration returns end time of last sample
+    // Use consistent precision handling throughout
+    const firstTimestampMs = roundToMilliseconds(
+      (await track.getFirstTimestamp()) * 1000,
+    );
+    let roundedTimeMs = roundToMilliseconds(timeMs);
+
+    // During rapid scrubbing, track.computeDuration() may only return the duration
+    // of currently loaded segments. Only validate against the start time, as the
+    // end time may not be accurate until all segments are loaded.
+    if (roundedTimeMs < firstTimestampMs) {
+      // GRACEFUL HANDLING: During rapid seeking, tasks can complete out of order, causing
+      // the audio buffer to contain segments for a different time range than the seek target.
+      // Only apply graceful adjustment if we have buffer contents that suggest a race condition.
+      // For empty buffers, allow normal seeking to proceed which may load the appropriate segments.
+
+      const bufferContents = trackBuffer.getContents();
+
+      if (bufferContents.length > 0) {
+        // We have loaded segments but they're for a different time range - adjust gracefully
+        timeMs = firstTimestampMs;
+        roundedTimeMs = roundToMilliseconds(timeMs);
+      } else {
+        // Empty buffer - let normal seeking proceed to load appropriate segments
+        // This maintains normal seeking behavior for tests and initial loads
+      }
+    }
+
+    // Note: If seeking beyond currently loaded segments, allow it to proceed
+    // The segment loading logic will handle fetching the needed segments
+    // No logging needed as this is a normal part of seeking behavior
 
-    if (timeMs < firstTimestampMs || timeMs >= lastSampleEndMs) {
-      throw new NoSample(
-        `Seek time ${timeMs}ms is outside track range [${firstTimestampMs}ms, ${lastSampleEndMs}ms]`,
+    // Check if we need to reset iterator for seeks outside current buffer range
+    const bufferContents = trackBuffer.getContents();
+    if (bufferContents.length > 0) {
+      const bufferStartMs = roundToMilliseconds(
+        trackBuffer.firstTimestamp * 1000,
       );
+      const lastSample = bufferContents[bufferContents.length - 1];
+      const bufferEndMs = lastSample
+        ? roundToMilliseconds(
+            (lastSample.timestamp + (lastSample.duration || 0)) * 1000,
+          )
+        : bufferStartMs;
+
+      // If seeking outside current buffer range, reset iterator to load appropriate data
+      if (roundedTimeMs < bufferStartMs || roundedTimeMs > bufferEndMs) {
+        await this.resetIterator(trackId);
+      }
     }
 
+    const alreadyInBuffer = trackBuffer.find(timeMs);
     if (alreadyInBuffer) return alreadyInBuffer;
 
     const iterator = await this.getTrackIterator(trackId);
@@ -260,6 +301,22 @@ export class BufferedSeekingInput {
       }
     }
 
+    // If no exact sample found and we've reached the end of the track,
+    // check if the seek time is beyond the actual track duration.
+    // If so, return the last available sample instead of throwing an error.
+    const finalBufferContents = trackBuffer.getContents();
+    if (finalBufferContents.length > 0) {
+      const lastSample = finalBufferContents[finalBufferContents.length - 1];
+      const lastSampleEndMs = roundToMilliseconds(
+        ((lastSample?.timestamp || 0) + (lastSample?.duration || 0)) * 1000,
+      );
+
+      // If seeking past the last sample, return the last sample silently
+      if (roundToMilliseconds(timeMs) >= lastSampleEndMs) {
+        return lastSample;
+      }
+    }
+
     throw new NoSample(
       `Sample not found for time ${timeMs} in ${track.type} track ${trackId}`,
     );

package/src/elements/EFMedia/JitMediaEngine.ts

@@ -41,6 +41,7 @@ export class JitMediaEngine extends BaseMediaEngine implements MediaEngine {
       trackId: undefined,
       src: this.data.sourceUrl,
       segmentDurationMs: rendition.segmentDurationMs,
+      segmentDurationsMs: rendition.segmentDurationsMs,
     };
   }
 
@@ -53,6 +54,7 @@ export class JitMediaEngine extends BaseMediaEngine implements MediaEngine {
       trackId: undefined,
       src: this.data.sourceUrl,
       segmentDurationMs: rendition.segmentDurationMs,
+      segmentDurationsMs: rendition.segmentDurationsMs,
     };
   }
 
@@ -96,15 +98,69 @@ export class JitMediaEngine extends BaseMediaEngine implements MediaEngine {
     desiredSeekTimeMs: number,
     rendition: VideoRendition | AudioRendition,
   ) {
+    // Don't request segments beyond the actual file duration
+    // Note: seeking to exactly durationMs should be allowed (it's the last moment of the file)
+    if (desiredSeekTimeMs > this.durationMs) {
+      return undefined;
+    }
+
+    // Use actual segment durations if available (more accurate)
+    if (
+      rendition.segmentDurationsMs &&
+      rendition.segmentDurationsMs.length > 0
+    ) {
+      let cumulativeTime = 0;
+
+      for (let i = 0; i < rendition.segmentDurationsMs.length; i++) {
+        const segmentDuration = rendition.segmentDurationsMs[i];
+        if (segmentDuration === undefined) {
+          throw new Error("Segment duration is required for JIT metadata");
+        }
+        const segmentStartMs = cumulativeTime;
+        const segmentEndMs = cumulativeTime + segmentDuration;
+
+        // Check if the desired seek time falls within this segment
+        // Special case: for the last segment, include the exact end time
+        const isLastSegment = i === rendition.segmentDurationsMs.length - 1;
+        const includesEndTime =
+          isLastSegment && desiredSeekTimeMs === this.durationMs;
+
+        if (
+          desiredSeekTimeMs >= segmentStartMs &&
+          (desiredSeekTimeMs < segmentEndMs || includesEndTime)
+        ) {
+          return i + 1; // Convert 0-based to 1-based segment ID
+        }
+
+        cumulativeTime += segmentDuration;
+
+        // If we've reached or exceeded file duration, stop
+        if (cumulativeTime >= this.durationMs) {
+          break;
+        }
+      }
+
+      // If we didn't find a segment, return undefined
+      return undefined;
+    }
+
+    // Fall back to fixed duration calculation for backward compatibility
     if (!rendition.segmentDurationMs) {
       throw new Error("Segment duration is required for JIT metadata");
     }
+
     const segmentIndex = Math.floor(
       desiredSeekTimeMs / rendition.segmentDurationMs,
     );
-    if (segmentIndex * rendition.segmentDurationMs >= this.durationMs) {
-      return segmentIndex; // Return 1-based index (segmentIndex is already 0-based, so segmentIndex for the last segment is what we want)
+
+    // Calculate the actual segment start time
+    const segmentStartMs = segmentIndex * rendition.segmentDurationMs;
+
+    // If this segment would start at or beyond file duration, it doesn't exist
+    if (segmentStartMs >= this.durationMs) {
+      return undefined;
     }
+
     return segmentIndex + 1; // Convert 0-based to 1-based
   }
 }

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

@@ -103,7 +103,16 @@ export function makeAudioFrequencyAnalysisTask(element: EFMedia) {
       // ONLY CHANGE: Get real audio data for analysis (same technique as playback)
       const analysisWindowMs = 5000; // Get 5 seconds for better analysis
       const fromMs = Math.max(0, currentTimeMs);
-      const toMs = fromMs + analysisWindowMs;
+      // Clamp toMs to video duration to prevent requesting segments beyond available content
+      const maxToMs = fromMs + analysisWindowMs;
+      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;
+      }
 
       const { fetchAudioSpanningTime: fetchAudioSpan } = await import(
         "../shared/AudioSpanUtils.ts"

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

@@ -17,19 +17,27 @@ export const makeAudioInputTask = (host: EFMedia): InputTask => {
       console.error("audioInputTask error", error);
     },
     onComplete: (_value) => {},
-    task: async () => {
+    task: async (_, { signal }) => {
       const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
+      signal.throwIfAborted(); // Abort if a new seek started
       const segment = await host.audioSegmentFetchTask.taskComplete;
+      signal.throwIfAborted(); // Abort if a new seek started
       if (!initSegment || !segment) {
         throw new Error("Init segment or segment is not available");
       }
-      return new BufferedSeekingInput(
-        await new Blob([initSegment, segment]).arrayBuffer(),
-        {
-          videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
-          audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
-        },
-      );
+
+      // Get startTimeOffsetMs from the audio rendition if available
+      const mediaEngine = await host.mediaEngineTask.taskComplete;
+      const audioRendition = mediaEngine?.audioRendition;
+      const startTimeOffsetMs = audioRendition?.startTimeOffsetMs;
+
+      const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
+      signal.throwIfAborted(); // Abort if a new seek started
+      return new BufferedSeekingInput(arrayBuffer, {
+        videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
+        audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
+        startTimeOffsetMs,
+      });
     },
   });
 };

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

@@ -0,0 +1,199 @@
+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("should not throw RangeError when seeking to exact 4000ms during playback", async ({
+    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("should not throw RangeError during progressive playback across segments", async ({
+    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("should not throw RangeError when localStorage restoration causes 0ms to 4000ms race condition", async ({
+    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
+    timegroup.currentTime = timegroup.maybeLoadTimeFromLocalStorage();
+
+    // 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("should not throw RangeError when forced segment coordination mismatch occurs", async ({
+    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("should not throw RangeError when rapidly crossing segment boundaries", async ({
+    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

@@ -13,16 +13,35 @@ export const makeAudioSeekTask = (host: EFMedia): AudioSeekTask => {
     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);
       }
-      console.error("audioSeekTask error", error);
     },
     onComplete: (_value) => {},
-    task: async (_): Promise<VideoSample | undefined> => {
+    task: async (
+      [targetSeekTimeMs],
+      { signal },
+    ): Promise<VideoSample | undefined> => {
+      // 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");
       }
@@ -30,11 +49,23 @@ export const makeAudioSeekTask = (host: EFMedia): AudioSeekTask => {
       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,
-        host.desiredSeekTimeMs,
-      )) as unknown as VideoSample;
+        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

@@ -20,7 +20,18 @@ export const makeAudioSegmentFetchTask = (
       const mediaEngine = await getLatestMediaEngine(host, signal);
       const segmentId = await host.audioSegmentIdTask.taskComplete;
       if (segmentId === undefined) {
-        throw new Error("Segment ID is not available");
+        // Provide more context in the error to help with debugging
+        const rendition = mediaEngine.audioRendition;
+        const debugInfo = {
+          hasRendition: !!rendition,
+          segmentDurationMs: rendition?.segmentDurationMs,
+          segmentDurationsMs: rendition?.segmentDurationsMs?.length || 0,
+          desiredSeekTimeMs: host.desiredSeekTimeMs,
+          intrinsicDurationMs: host.intrinsicDurationMs,
+        };
+        throw new Error(
+          `Segment ID is not available for audio. Debug info: ${JSON.stringify(debugInfo)}`,
+        );
       }
 
       // SIMPLIFIED: Direct call to mediaEngine - deduplication is built-in

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

@@ -12,10 +12,11 @@ export const makeAudioSegmentIdTask = (
       console.error("audioSegmentIdTask error", error);
     },
     onComplete: (_value) => {},
-    task: async (_, { signal }) => {
+    task: async ([, targetSeekTimeMs], { signal }) => {
       const mediaEngine = await getLatestMediaEngine(host, signal);
+      signal.throwIfAborted(); // Abort if a new seek started
       return mediaEngine.computeSegmentId(
-        host.desiredSeekTimeMs,
+        targetSeekTimeMs, // Use captured value, not host.desiredSeekTimeMs
         mediaEngine.getAudioRendition(),
       );
     },

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

@@ -35,7 +35,16 @@ export function makeAudioTimeDomainAnalysisTask(element: EFMedia) {
       // ONLY CHANGE: Get real audio data for analysis (same technique as playback)
       const analysisWindowMs = 5000; // Get 5 seconds for better analysis
       const fromMs = Math.max(0, currentTimeMs);
-      const toMs = fromMs + analysisWindowMs;
+      // Clamp toMs to video duration to prevent requesting segments beyond available content
+      const maxToMs = fromMs + analysisWindowMs;
+      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;
+      }
 
       const { fetchAudioSpanningTime: fetchAudioSpan } = await import(
         "../shared/AudioSpanUtils.ts"

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

@@ -0,0 +1,46 @@
+/**
+ * Centralized precision utilities for consistent timing calculations across the media pipeline.
+ *
+ * The key insight is that floating-point precision errors can cause inconsistencies between:
+ * 1. Segment selection logic (in AssetMediaEngine.computeSegmentId)
+ * 2. Sample finding logic (in SampleBuffer.find)
+ * 3. Timeline mapping (in BufferedSeekingInput.seek)
+ *
+ * All timing calculations must use the same rounding strategy to ensure consistency.
+ */
+
+/**
+ * Round time to millisecond precision to handle floating-point precision issues.
+ * Uses Math.round for consistent behavior across the entire pipeline.
+ *
+ * This function should be used for ALL time-related calculations that need to be
+ * compared between different parts of the system.
+ */
+export const roundToMilliseconds = (timeMs: number): number => {
+  // Round to 3 decimal places (microsecond precision)
+  return Math.round(timeMs * 1000) / 1000;
+};
+
+/**
+ * Convert media time (in seconds) to scaled time units using consistent rounding.
+ * This is used in segment selection to convert from milliseconds to timescale units.
+ */
+export const convertToScaledTime = (
+  timeMs: number,
+  timescale: number,
+): number => {
+  const scaledTime = (timeMs / 1000) * timescale;
+  return Math.round(scaledTime);
+};
+
+/**
+ * Convert scaled time units back to media time (in milliseconds) using consistent rounding.
+ * This is the inverse of convertToScaledTime.
+ */
+export const convertFromScaledTime = (
+  scaledTime: number,
+  timescale: number,
+): number => {
+  const timeMs = (scaledTime / timescale) * 1000;
+  return roundToMilliseconds(timeMs);
+};