@editframe/elements 0.20.2-beta.0 → 0.20.4-beta.0

package/src/elements/EFMedia/AssetMediaEngine.browsertest.ts

@@ -57,8 +57,9 @@ describe("AssetMediaEngine", () => {
     expect,
   }) => {
     const audioRendition = mediaEngine.audioRendition;
-    expect(audioRendition.trackId).toBe(2);
-    expect(audioRendition.src).toBe(host.src);
+    expect(audioRendition).toBeDefined();
+    expect(audioRendition!.trackId).toBe(2);
+    expect(audioRendition!.src).toBe(host.src);
   });
 
   test("returns video rendition with correct properties", ({
@@ -67,9 +68,10 @@ describe("AssetMediaEngine", () => {
     expect,
   }) => {
     const videoRendition = mediaEngine.videoRendition;
-    expect(videoRendition.trackId).toBe(1);
-    expect(videoRendition.src).toBe(host.src);
-    expect(videoRendition.startTimeOffsetMs).toBeCloseTo(66.6, 0);
+    expect(videoRendition).toBeDefined();
+    expect(videoRendition!.trackId).toBe(1);
+    expect(videoRendition!.src).toBe(host.src);
+    expect(videoRendition!.startTimeOffsetMs).toBeCloseTo(66.6, 0);
   });
 
   test("provides templates for asset endpoints", ({ mediaEngine, expect }) => {
@@ -100,39 +102,39 @@ describe("AssetMediaEngine", () => {
 
   describe("bars n tone segment id computation", () => {
     test("computes 0ms is 0", ({ expect, mediaEngine }) => {
-      expect(
-        mediaEngine.computeSegmentId(0, mediaEngine.getVideoRendition()),
-      ).toBe(0);
+      const videoRendition = mediaEngine.getVideoRendition();
+      expect(videoRendition).toBeDefined();
+      expect(mediaEngine.computeSegmentId(0, videoRendition!)).toBe(0);
     });
 
     test("computes 2000 is 1", ({ expect, mediaEngine }) => {
-      expect(
-        mediaEngine.computeSegmentId(2000, mediaEngine.getVideoRendition()),
-      ).toBe(1);
+      const videoRendition = mediaEngine.getVideoRendition();
+      expect(videoRendition).toBeDefined();
+      expect(mediaEngine.computeSegmentId(2000, videoRendition!)).toBe(1);
     });
 
     test("computes 4000 is 2", ({ expect, mediaEngine }) => {
-      expect(
-        mediaEngine.computeSegmentId(4000, mediaEngine.getVideoRendition()),
-      ).toBe(2);
+      const videoRendition = mediaEngine.getVideoRendition();
+      expect(videoRendition).toBeDefined();
+      expect(mediaEngine.computeSegmentId(4000, videoRendition!)).toBe(2);
     });
 
     test("computes 6000 is 3", ({ expect, mediaEngine }) => {
-      expect(
-        mediaEngine.computeSegmentId(6000, mediaEngine.getVideoRendition()),
-      ).toBe(3);
+      const videoRendition = mediaEngine.getVideoRendition();
+      expect(videoRendition).toBeDefined();
+      expect(mediaEngine.computeSegmentId(6000, videoRendition!)).toBe(3);
     });
 
     test("computes 8000 is 4", ({ expect, mediaEngine }) => {
-      expect(
-        mediaEngine.computeSegmentId(8000, mediaEngine.getVideoRendition()),
-      ).toBe(4);
+      const videoRendition = mediaEngine.getVideoRendition();
+      expect(videoRendition).toBeDefined();
+      expect(mediaEngine.computeSegmentId(8000, videoRendition!)).toBe(4);
     });
 
     test("computes 7975 is  3", ({ expect, mediaEngine }) => {
-      expect(
-        mediaEngine.computeSegmentId(7975, mediaEngine.getVideoRendition()),
-      ).toBe(3);
+      const videoRendition = mediaEngine.getVideoRendition();
+      expect(videoRendition).toBeDefined();
+      expect(mediaEngine.computeSegmentId(7975, videoRendition!)).toBe(3);
     });
   });
 });

package/src/elements/EFMedia/AssetMediaEngine.ts

@@ -54,16 +54,28 @@ export class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
   }
 
   get videoRendition() {
+    const videoTrack = this.videoTrackIndex;
+
+    if (!videoTrack || videoTrack.track === undefined) {
+      return undefined;
+    }
+
     return {
-      trackId: this.videoTrackIndex?.track,
+      trackId: videoTrack.track,
       src: this.src,
-      startTimeOffsetMs: this.videoTrackIndex?.startTimeOffsetMs,
+      startTimeOffsetMs: videoTrack.startTimeOffsetMs,
     };
   }
 
   get audioRendition() {
+    const audioTrack = this.audioTrackIndex;
+
+    if (!audioTrack || audioTrack.track === undefined) {
+      return undefined;
+    }
+
     return {
-      trackId: this.audioTrackIndex?.track,
+      trackId: audioTrack.track,
       src: this.src,
     };
   }
@@ -322,9 +334,7 @@ export class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
       // This is because Asset segments are independent timeline fragments
 
       if (!rendition.trackId) {
-        throw new Error(
-          "[convertToSegmentRelativeTimestamps] Track ID is required for asset metadata",
-        );
+        throw new Error("Track ID is required for asset metadata");
       }
       // For AssetMediaEngine, we need to calculate the actual segment start time
       // using the precise segment boundaries from the track fragment index

package/src/elements/EFMedia/BaseMediaEngine.browsertest.ts

@@ -34,6 +34,100 @@ class TestMediaEngine extends BaseMediaEngine {
   }
 }
 
+// Test implementation for video-only assets
+// @ts-expect-error missing implementations
+class VideoOnlyMediaEngine extends BaseMediaEngine {
+  fetchMediaSegment = vi.fn();
+  public host: EFMedia;
+
+  constructor(host: EFMedia) {
+    super(host);
+    this.host = host;
+  }
+
+  get videoRendition() {
+    return {
+      trackId: 1,
+      src: "test-video.mp4",
+      segmentDurationMs: 2000,
+    };
+  }
+
+  get audioRendition() {
+    return undefined; // Video-only asset
+  }
+}
+
+// Test implementation for audio-only assets
+// @ts-expect-error missing implementations
+class AudioOnlyMediaEngine extends BaseMediaEngine {
+  fetchMediaSegment = vi.fn();
+  public host: EFMedia;
+
+  constructor(host: EFMedia) {
+    super(host);
+    this.host = host;
+  }
+
+  get videoRendition() {
+    return undefined; // Audio-only asset
+  }
+
+  get audioRendition() {
+    return {
+      trackId: 1,
+      src: "test-audio.mp4",
+      segmentDurationMs: 1000,
+    };
+  }
+}
+
+describe("BaseMediaEngine API Contract", () => {
+  test("getAudioRendition returns audio rendition when available", ({
+    expect,
+  }) => {
+    const host = document.createElement("ef-video") as EFMedia;
+    const engine = new TestMediaEngine(host);
+
+    const result = engine.getAudioRendition();
+    expect(result).toBeDefined();
+    expect(result?.trackId).toBe(2);
+    expect(result?.src).toBe("test-audio.mp4");
+  });
+
+  test("getAudioRendition returns undefined for video-only assets", ({
+    expect,
+  }) => {
+    const host = document.createElement("ef-video") as EFMedia;
+    const engine = new VideoOnlyMediaEngine(host);
+
+    const result = engine.getAudioRendition();
+    expect(result).toBeUndefined();
+  });
+
+  test("getVideoRendition returns video rendition when available", ({
+    expect,
+  }) => {
+    const host = document.createElement("ef-video") as EFMedia;
+    const engine = new TestMediaEngine(host);
+
+    const result = engine.getVideoRendition();
+    expect(result).toBeDefined();
+    expect(result?.trackId).toBe(1);
+    expect(result?.src).toBe("test-video.mp4");
+  });
+
+  test("getVideoRendition returns undefined for audio-only assets", ({
+    expect,
+  }) => {
+    const host = document.createElement("ef-audio") as EFMedia;
+    const engine = new AudioOnlyMediaEngine(host);
+
+    const result = engine.getVideoRendition();
+    expect(result).toBeUndefined();
+  });
+});
+
 describe("BaseMediaEngine deduplication", () => {
   test("should fetch segment successfully", async ({ expect }) => {
     const host = document.createElement("ef-video") as EFMedia;

package/src/elements/EFMedia/BaseMediaEngine.ts

@@ -23,17 +23,19 @@ export abstract class BaseMediaEngine {
   abstract get videoRendition(): VideoRendition | undefined;
   abstract get audioRendition(): AudioRendition | undefined;
 
-  getVideoRendition(): VideoRendition {
-    if (!this.videoRendition) {
-      throw new Error("No video rendition available");
-    }
+  /**
+   * Get video rendition if available. Returns undefined for audio-only assets.
+   * Callers should handle undefined gracefully.
+   */
+  getVideoRendition(): VideoRendition | undefined {
     return this.videoRendition;
   }
 
-  getAudioRendition(): AudioRendition {
-    if (!this.audioRendition) {
-      throw new Error("No audio rendition available");
-    }
+  /**
+   * Get audio rendition if available. Returns undefined for video-only assets.
+   * Callers should handle undefined gracefully.
+   */
+  getAudioRendition(): AudioRendition | undefined {
     return this.audioRendition;
   }
 

package/src/elements/EFMedia/JitMediaEngine.ts

@@ -215,15 +215,29 @@ export class JitMediaEngine extends BaseMediaEngine implements MediaEngine {
   async extractThumbnails(
     timestamps: number[],
   ): Promise<(ThumbnailResult | null)[]> {
-    const mainRendition = this.videoRendition;
-    const scrubRendition = this.getScrubVideoRendition();
-
-    const rendition = mainRendition || scrubRendition;
-
-    if (!rendition) {
+    // Use same rendition priority as video: try main rendition first for frame alignment
+    let rendition: VideoRendition;
+    try {
+      const mainRendition = this.getVideoRendition();
+      if (mainRendition) {
+        rendition = mainRendition;
+      } else {
+        const scrubRendition = this.getScrubVideoRendition();
+        if (scrubRendition) {
+          rendition = scrubRendition;
+        } else {
+          throw new Error("No video rendition available");
+        }
+      }
+    } catch (error) {
+      console.warn(
+        "JitMediaEngine: No video rendition available for thumbnails",
+        error,
+      );
       return timestamps.map(() => null);
     }
 
+    // Use shared thumbnail extraction logic
     return this.thumbnailExtractor.extractThumbnails(
       timestamps,
       rendition,

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

@@ -42,15 +42,18 @@ export const makeAudioBufferTask = (host: EFMedia): AudioBufferTask => {
     task: async ([seekTimeMs], { signal }) => {
       // Skip buffering entirely in rendering mode
       if (EF_RENDERING()) {
-        return currentState;
+        return currentState; // Return existing state without any buffering activity
       }
 
+      // Get media engine to potentially override buffer configuration
       const mediaEngine = await getLatestMediaEngine(host, signal);
 
+      // Return existing state if no audio rendition available
       if (!mediaEngine.audioRendition) {
         return currentState;
       }
 
+      // Use media engine's buffer config, falling back to host properties
       const engineConfig = mediaEngine.getBufferConfig();
       const bufferDurationMs = engineConfig.audioBufferDurationMs;
       const maxParallelFetches = engineConfig.maxAudioBufferFetches;
@@ -90,7 +93,7 @@ export const makeAudioBufferTask = (host: EFMedia): AudioBufferTask => {
             const mediaEngine = await getLatestMediaEngine(host, signal);
             const audioRendition = mediaEngine.audioRendition;
             if (!audioRendition) {
-              throw new Error("No audio track available in source");
+              throw new Error("Audio rendition not available");
             }
             return audioRendition;
           },

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

@@ -95,11 +95,6 @@ export function makeAudioFrequencyAnalysisTask(element: EFMedia) {
     task: async (_, { signal }) => {
       if (element.currentSourceTimeMs < 0) return null;
 
-      const mediaEngine = element.mediaEngineTask.value;
-      if (!mediaEngine?.audioRendition) {
-        return null;
-      }
-
       const currentTimeMs = element.currentSourceTimeMs;
 
       // Calculate exact audio window needed based on fftDecay and frame timing

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

@@ -14,8 +14,9 @@ export const makeAudioInitSegmentFetchTask = (
     onComplete: (_value) => {},
     task: async ([_mediaEngine], { signal }) => {
       const mediaEngine = await getLatestMediaEngine(host, signal);
+      const audioRendition = mediaEngine.getAudioRendition();
 
-      const audioRendition = mediaEngine.audioRendition;
+      // Return undefined if no audio rendition available (video-only asset)
       if (!audioRendition) {
         return undefined;
       }

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

@@ -6,7 +6,7 @@ import type { InputTask } from "../shared/MediaTaskUtils";
 export const makeAudioInputTask = (host: EFMedia): InputTask => {
   return new Task<
     readonly [ArrayBuffer | undefined, ArrayBuffer | undefined],
-    BufferedSeekingInput
+    BufferedSeekingInput | undefined
   >(host, {
     args: () =>
       [
@@ -18,18 +18,24 @@ export const makeAudioInputTask = (host: EFMedia): InputTask => {
     },
     onComplete: (_value) => {},
     task: async (_, { signal }) => {
+      const mediaEngine = await host.mediaEngineTask.taskComplete;
+      const audioRendition = mediaEngine?.audioRendition;
+
+      // Return undefined if no audio rendition available (video-only asset)
+      if (!audioRendition) {
+        return undefined;
+      }
+
       const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
       signal.throwIfAborted();
       const segment = await host.audioSegmentFetchTask.taskComplete;
       signal.throwIfAborted();
 
       if (!initSegment || !segment) {
-        throw new Error("No audio track available in source");
+        return undefined;
       }
 
-      const mediaEngine = await host.mediaEngineTask.taskComplete;
-      const audioRendition = mediaEngine?.audioRendition;
-      const startTimeOffsetMs = audioRendition?.startTimeOffsetMs;
+      const startTimeOffsetMs = audioRendition.startTimeOffsetMs;
 
       const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
       signal.throwIfAborted();

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

@@ -18,26 +18,14 @@ export const makeAudioSegmentFetchTask = (
     onComplete: (_value) => {},
     task: async (_, { signal }) => {
       const mediaEngine = await getLatestMediaEngine(host, signal);
+      const segmentId = await host.audioSegmentIdTask.taskComplete;
+      const audioRendition = mediaEngine.getAudioRendition();
 
-      const audioRendition = mediaEngine.audioRendition;
-      if (!audioRendition) {
+      // Return undefined if no audio rendition or segment ID available (video-only asset)
+      if (!audioRendition || segmentId === undefined) {
         return undefined;
       }
 
-      const segmentId = await host.audioSegmentIdTask.taskComplete;
-      if (segmentId === undefined) {
-        const debugInfo = {
-          hasRendition: true,
-          segmentDurationMs: audioRendition.segmentDurationMs,
-          segmentDurationsMs: audioRendition.segmentDurationsMs?.length || 0,
-          desiredSeekTimeMs: host.desiredSeekTimeMs,
-          intrinsicDurationMs: host.intrinsicDurationMs,
-        };
-        throw new Error(
-          `Segment ID is not available for audio. Debug info: ${JSON.stringify(debugInfo)}`,
-        );
-      }
-
       return mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
     },
   });

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

@@ -14,9 +14,11 @@ export const makeAudioSegmentIdTask = (
     onComplete: (_value) => {},
     task: async ([, targetSeekTimeMs], { signal }) => {
       const mediaEngine = await getLatestMediaEngine(host, signal);
-      signal.throwIfAborted(); // Abort if a new seek started
+      signal.throwIfAborted();
 
-      const audioRendition = mediaEngine.audioRendition;
+      const audioRendition = mediaEngine.getAudioRendition();
+
+      // Return undefined if no audio rendition available (video-only asset)
       if (!audioRendition) {
         return undefined;
       }

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

@@ -0,0 +1,95 @@
+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

@@ -2,7 +2,7 @@ import { Task } from "@lit/task";
 
 import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { LRUCache } from "../../../utils/LRUCache.js";
-import type { EFMedia } from "../../EFMedia.js";
+import { type EFMedia, IgnorableError } from "../../EFMedia.js";
 
 // DECAY_WEIGHT constant - same as original
 const DECAY_WEIGHT = 0.8;
@@ -14,6 +14,10 @@ export function makeAudioTimeDomainAnalysisTask(element: EFMedia) {
   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: () =>
@@ -27,11 +31,6 @@ export function makeAudioTimeDomainAnalysisTask(element: EFMedia) {
     task: async (_, { signal }) => {
       if (element.currentSourceTimeMs < 0) return null;
 
-      const mediaEngine = element.mediaEngineTask.value;
-      if (!mediaEngine?.audioRendition) {
-        return null;
-      }
-
       const currentTimeMs = element.currentSourceTimeMs;
 
       // Calculate exact audio window needed based on fftDecay and frame timing

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

@@ -16,7 +16,7 @@ const fetchAudioSegmentData = async (
 ): Promise<Map<number, ArrayBuffer>> => {
   const audioRendition = mediaEngine.audioRendition;
   if (!audioRendition) {
-    throw new Error("No audio track available in source");
+    throw new Error("Audio rendition not available");
   }
 
   const segmentData = new Map<number, ArrayBuffer>();
@@ -62,7 +62,7 @@ export const fetchAudioSpanningTime = async (
   fromMs: number,
   toMs: number,
   signal: AbortSignal,
-): Promise<AudioSpan> => {
+): Promise<AudioSpan | undefined> => {
   // Validate inputs
   if (fromMs >= toMs || fromMs < 0) {
     throw new Error(`Invalid time range: fromMs=${fromMs}, toMs=${toMs}`);
@@ -72,12 +72,13 @@ export const fetchAudioSpanningTime = async (
   const mediaEngine = await host.mediaEngineTask.taskComplete;
   const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
 
+  // Return undefined if no audio rendition available
   if (!mediaEngine?.audioRendition) {
-    throw new Error("No audio track available in source");
+    return undefined;
   }
 
   if (!initSegment) {
-    throw new Error("Audio init segment is not available");
+    return undefined;
   }
 
   // Calculate segments needed using the media engine's method

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

@@ -35,7 +35,7 @@ export interface MediaBufferDependencies<
   ) => Promise<number | undefined>;
   prefetchSegment: (segmentId: number, rendition: T) => Promise<void>; // Just trigger prefetch, don't return data
   isSegmentCached: (segmentId: number, rendition: T) => boolean; // Check BaseMediaEngine cache
-  getRendition: () => Promise<T>;
+  getRendition: () => Promise<T | undefined>;
   logError: (message: string, error: any) => void;
 }
 
@@ -208,6 +208,10 @@ export const manageMediaBuffer = async <
   }
 
   const rendition = await deps.getRendition();
+  if (!rendition) {
+    // Cannot buffer without a rendition
+    return currentState;
+  }
   const endTimeMs = seekTimeMs + config.bufferDurationMs;
 
   const desiredSegments = await computeSegmentRangeAsync(
@@ -217,7 +221,6 @@ export const manageMediaBuffer = async <
     rendition,
     deps.computeSegmentId,
   );
-
   // Filter out segments already cached by BaseMediaEngine
   const uncachedSegments = desiredSegments.filter(
     (segmentId) => !deps.isSegmentCached(segmentId, rendition),
@@ -287,10 +290,11 @@ export const manageMediaBuffer = async <
     startNextSegment();
   }
 
-  return {
+  const result = {
     currentSeekTimeMs: seekTimeMs,
     requestedSegments: newRequestedSegments,
     activeRequests: newActiveRequests,
     requestQueue: remainingQueue, // What's left in the queue
   };
+  return result;
 };

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

@@ -40,5 +40,5 @@ export type SegmentFetchTask = Task<
  */
 export type InputTask = Task<
   readonly [ArrayBuffer, ArrayBuffer],
-  BufferedSeekingInput
+  BufferedSeekingInput | undefined
 >;