@editframe/elements 0.26.3-beta.0 → 0.30.0-beta.13

package/src/elements/EFMedia/tasks/makeMediaEngineTask.ts

@@ -1,88 +0,0 @@
-import { Task } from "@lit/task";
-import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE";
-import type { MediaEngine } from "../../../transcoding/types";
-import type { EFMedia } from "../../EFMedia";
-import { AssetIdMediaEngine } from "../AssetIdMediaEngine";
-import { AssetMediaEngine } from "../AssetMediaEngine";
-import { JitMediaEngine } from "../JitMediaEngine";
-
-export const getLatestMediaEngine = async (
-  host: EFMedia,
-  signal: AbortSignal,
-): Promise<MediaEngine> => {
-  const mediaEngine = await host.mediaEngineTask.taskComplete;
-  signal.throwIfAborted();
-  if (!mediaEngine) {
-    throw new Error("Media engine is not available");
-  }
-  return mediaEngine;
-};
-
-/**
- * Core logic for creating a MediaEngine with explicit dependencies.
- * Pure function that requires all dependencies to be provided.
- */
-export const createMediaEngine = (host: EFMedia): Promise<MediaEngine> => {
-  const { src, assetId, urlGenerator, apiHost } = host;
-
-  // Check for AssetID mode first
-  if (assetId !== null && assetId !== undefined && assetId.trim() !== "") {
-    if (!apiHost) {
-      return Promise.reject(new Error("API host is required for AssetID mode"));
-    }
-    return AssetIdMediaEngine.fetchByAssetId(
-      host,
-      urlGenerator,
-      assetId,
-      apiHost,
-    );
-  }
-
-  // Check for null/undefined/empty/whitespace src
-  if (!src || typeof src !== "string" || src.trim() === "") {
-    console.error(`Unsupported media source: ${src}, assetId: ${assetId}`);
-    return Promise.reject(new Error("Unsupported media source"));
-  }
-
-  const lowerSrc = src.toLowerCase();
-  if (!lowerSrc.startsWith("http://") && !lowerSrc.startsWith("https://")) {
-    return AssetMediaEngine.fetch(host, urlGenerator, src);
-  }
-
-  // Remote (http/https) source, now check configuration
-  const configuration = host.closest("ef-configuration");
-  if (configuration?.mediaEngine === "local") {
-    // Only use AssetMediaEngine for remote URLs when explicitly configured
-    return AssetMediaEngine.fetch(host, urlGenerator, src);
-  }
-
-  // Default: Use JitMediaEngine for remote URLs (transcoding service)
-  const url = urlGenerator.generateManifestUrl(src);
-  return JitMediaEngine.fetch(host, urlGenerator, url);
-};
-
-/**
- * Handle completion of media engine task - triggers necessary updates.
- * Extracted for testability.
- */
-export const handleMediaEngineComplete = (host: EFMedia): void => {
-  host.requestUpdate("intrinsicDurationMs");
-  host.requestUpdate("ownCurrentTimeMs");
-  host.rootTimegroup?.requestUpdate("ownCurrentTimeMs");
-  host.rootTimegroup?.requestUpdate("durationMs");
-};
-
-type MediaEngineTask = Task<readonly [string, string | null], MediaEngine>;
-
-export const makeMediaEngineTask = (host: EFMedia): MediaEngineTask => {
-  return new Task(host, {
-    autoRun: EF_INTERACTIVE,
-    args: () => [host.src, host.assetId] as const,
-    task: async () => {
-      return createMediaEngine(host);
-    },
-    onComplete: (_value) => {
-      handleMediaEngineComplete(host);
-    },
-  });
-};

package/src/elements/EFMedia/videoTasks/MainVideoInputCache.ts

@@ -1,76 +0,0 @@
-import type { BufferedSeekingInput } from "../BufferedSeekingInput";
-
-/**
- * Cache for main video BufferedSeekingInput instances
- * Main video segments are typically 2s long, so we can reuse the same input
- * for multiple frames within that segment (e.g., 60 frames at 30fps)
- */
-export class MainVideoInputCache {
-  private cache = new Map<string, BufferedSeekingInput>();
-  private maxCacheSize = 10; // Keep last 10 main inputs (covers 20 seconds at 2s/segment)
-
-  /**
-   * Create a cache key that uniquely identifies a segment
-   */
-  private getCacheKey(
-    src: string,
-    segmentId: number,
-    renditionId: string | undefined,
-  ): string {
-    return `${src}:${renditionId || "default"}:${segmentId}`;
-  }
-
-  /**
-   * Get or create BufferedSeekingInput for a main video segment
-   */
-  async getOrCreateInput(
-    src: string,
-    segmentId: number,
-    renditionId: string | undefined,
-    createInputFn: () => Promise<BufferedSeekingInput | undefined>,
-  ): Promise<BufferedSeekingInput | undefined> {
-    const cacheKey = this.getCacheKey(src, segmentId, renditionId);
-
-    // Check if we already have this segment cached
-    const cached = this.cache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-
-    // Create new input
-    const input = await createInputFn();
-    if (!input) {
-      return undefined;
-    }
-
-    // Add to cache and maintain size limit
-    this.cache.set(cacheKey, input);
-
-    // Evict oldest entries if cache is too large (LRU-like behavior)
-    if (this.cache.size > this.maxCacheSize) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== undefined) {
-        this.cache.delete(oldestKey);
-      }
-    }
-
-    return input;
-  }
-
-  /**
-   * Clear the entire cache (called when video changes)
-   */
-  clear() {
-    this.cache.clear();
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    return {
-      size: this.cache.size,
-      cacheKeys: Array.from(this.cache.keys()),
-    };
-  }
-}

package/src/elements/EFMedia/videoTasks/ScrubInputCache.ts

@@ -1,61 +0,0 @@
-import type { BufferedSeekingInput } from "../BufferedSeekingInput";
-
-/**
- * Cache for scrub BufferedSeekingInput instances
- * Since scrub segments are 30s long, we can reuse the same input for many seeks
- * within that time range, making scrub seeking very efficient
- */
-export class ScrubInputCache {
-  private cache = new Map<number, BufferedSeekingInput>();
-  private maxCacheSize = 5; // Keep last 5 scrub inputs (covers 2.5 minutes)
-
-  /**
-   * Get or create BufferedSeekingInput for a scrub segment
-   */
-  async getOrCreateInput(
-    segmentId: number,
-    createInputFn: () => Promise<BufferedSeekingInput | undefined>,
-  ): Promise<BufferedSeekingInput | undefined> {
-    // Check if we already have this segment cached
-    const cached = this.cache.get(segmentId);
-    if (cached) {
-      return cached;
-    }
-
-    // Create new input
-    const input = await createInputFn();
-    if (!input) {
-      return undefined;
-    }
-
-    // Add to cache and maintain size limit
-    this.cache.set(segmentId, input);
-
-    // Evict oldest entries if cache is too large
-    if (this.cache.size > this.maxCacheSize) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== undefined) {
-        this.cache.delete(oldestKey);
-      }
-    }
-
-    return input;
-  }
-
-  /**
-   * Clear the entire cache (called when video changes)
-   */
-  clear() {
-    this.cache.clear();
-  }
-
-  /**
-   * Get cache statistics
-   */
-  getStats() {
-    return {
-      size: this.cache.size,
-      segmentIds: Array.from(this.cache.keys()),
-    };
-  }
-}

package/src/elements/EFMedia/videoTasks/makeScrubVideoBufferTask.ts

@@ -1,114 +0,0 @@
-import { Task } from "@lit/task";
-
-import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
-import { EF_RENDERING } from "../../../EF_RENDERING.js";
-import type { VideoRendition } from "../../../transcoding/types";
-import type { EFVideo } from "../../EFVideo";
-import type { MediaBufferState } from "../shared/BufferUtils";
-import { manageMediaBuffer } from "../shared/BufferUtils";
-
-/**
- * Scrub video buffer task - aggressively preloads the ENTIRE scrub track
- * Unlike main video buffering, this loads the full duration with higher concurrency
- * for instant visual feedback during seeking
- */
-export const makeScrubVideoBufferTask = (host: EFVideo) => {
-  let currentState: MediaBufferState = {
-    currentSeekTimeMs: 0,
-    requestedSegments: new Set(),
-    activeRequests: new Set(),
-    requestQueue: [],
-  };
-
-  return new Task(host, {
-    autoRun: EF_INTERACTIVE,
-    args: () => [host.mediaEngineTask.value] as const,
-    onError: (error) => {
-      console.error("scrubVideoBufferTask error", error);
-    },
-    onComplete: (value) => {
-      currentState = value as MediaBufferState;
-    },
-    task: async ([mediaEngine], { signal }) => {
-      // Skip entirely in rendering mode
-      if (EF_RENDERING()) {
-        return currentState;
-      }
-
-      // Don't run if video buffering is disabled
-      if (!host.enableVideoBuffering) {
-        return currentState;
-      }
-
-      // Need media engine to be available
-      if (!mediaEngine) {
-        return currentState;
-      }
-
-      // Get scrub rendition using the proper interface method
-      const scrubRendition = mediaEngine.getScrubVideoRendition();
-
-      if (!scrubRendition) {
-        // No scrub rendition available - this is fine, just return current state
-        return currentState;
-      }
-
-      // Add src to rendition
-      const scrubRenditionWithSrc = {
-        ...scrubRendition,
-        src: mediaEngine.src,
-      };
-
-      try {
-        // First, ensure the init segment is cached for scrub content
-        try {
-          await mediaEngine.fetchInitSegment(scrubRenditionWithSrc, signal);
-        } catch (error) {
-          console.warn(
-            "ScrubBuffer: Failed to cache scrub init segment:",
-            error,
-          );
-        }
-
-        // Aggressively buffer the ENTIRE scrub track
-        const newState = await manageMediaBuffer<VideoRendition>(
-          0, // Always start from beginning to ensure complete coverage
-          {
-            // Buffer entire duration - scrub segments are 30s so much fewer total segments
-            bufferDurationMs: mediaEngine.durationMs,
-            // High concurrency for scrub - fewer segments overall (30s each vs 2s for main)
-            // E.g., 10min video = ~20 scrub segments vs ~300 main segments
-            maxParallelFetches: 10,
-            enableBuffering: true,
-            enableContinuousBuffering: true, // Keep going until all segments loaded
-          },
-          currentState,
-          mediaEngine.durationMs,
-          signal,
-          {
-            computeSegmentId: async (timeMs, rendition) => {
-              return mediaEngine.computeSegmentId(timeMs, rendition);
-            },
-            prefetchSegment: async (segmentId, rendition) => {
-              // Use the media engine to fetch and cache scrub segments
-              await mediaEngine.fetchMediaSegment(segmentId, rendition);
-            },
-            isSegmentCached: (segmentId, rendition) => {
-              return mediaEngine.isSegmentCached(segmentId, rendition);
-            },
-            getRendition: async () => scrubRenditionWithSrc,
-            logError: (message, error) => {
-              console.warn(`ScrubBuffer: ${message}`, error);
-            },
-          },
-        );
-
-        return newState;
-      } catch (error) {
-        if (signal.aborted) return currentState;
-        console.warn("ScrubBuffer failed:", error);
-        return currentState;
-      }
-    },
-  });
-};

package/src/elements/EFMedia/videoTasks/makeScrubVideoInitSegmentFetchTask.ts

@@ -1,35 +0,0 @@
-import { Task } from "@lit/task";
-import type { MediaEngine } from "../../../transcoding/types";
-import type { EFVideo } from "../../EFVideo";
-import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
-
-export const makeScrubVideoInitSegmentFetchTask = (
-  host: EFVideo,
-): Task<readonly [MediaEngine | undefined], ArrayBuffer> => {
-  return new Task(host, {
-    args: () => [host.mediaEngineTask.value] as const,
-    onError: (error) => {
-      console.error("scrubVideoInitSegmentFetchTask error", error);
-    },
-    onComplete: (_value) => {},
-    task: async ([_mediaEngine], { signal }) => {
-      const mediaEngine = await getLatestMediaEngine(host, signal);
-
-      // Get scrub rendition using the proper interface method
-      const scrubRendition = mediaEngine.getScrubVideoRendition();
-
-      if (!scrubRendition) {
-        // No scrub rendition available - this is fine, scrub is optional
-        throw new Error("No scrub rendition available");
-      }
-
-      return mediaEngine.fetchInitSegment(
-        {
-          ...scrubRendition,
-          src: mediaEngine.src, // Ensure src is set
-        },
-        signal,
-      );
-    },
-  });
-};

package/src/elements/EFMedia/videoTasks/makeScrubVideoInputTask.ts

@@ -1,52 +0,0 @@
-import { Task } from "@lit/task";
-
-import { EFMedia } from "../../EFMedia";
-import type { EFVideo } from "../../EFVideo";
-import { BufferedSeekingInput } from "../BufferedSeekingInput";
-import type { InputTask } from "../shared/MediaTaskUtils";
-
-export const makeScrubVideoInputTask = (host: EFVideo): InputTask => {
-  return new Task<
-    readonly [ArrayBuffer | undefined, ArrayBuffer | undefined],
-    BufferedSeekingInput | undefined
-  >(host, {
-    args: () =>
-      [
-        host.scrubVideoInitSegmentFetchTask.value,
-        host.scrubVideoSegmentFetchTask.value,
-      ] as const,
-    onError: (error) => {
-      console.error("scrubVideoInputTask error", error);
-    },
-    onComplete: (_value) => {},
-    task: async (_, { signal }) => {
-      const initSegment =
-        await host.scrubVideoInitSegmentFetchTask.taskComplete;
-      if (signal.aborted) return undefined;
-
-      const segment = await host.scrubVideoSegmentFetchTask.taskComplete;
-      if (signal.aborted) return undefined;
-
-      if (!initSegment || !segment) {
-        throw new Error("Scrub init segment or segment is not available");
-      }
-
-      // Get startTimeOffsetMs from the scrub rendition if available
-      const mediaEngine = await host.mediaEngineTask.taskComplete;
-      if (signal.aborted) return undefined;
-
-      const scrubRendition = mediaEngine.getScrubVideoRendition();
-      const startTimeOffsetMs = scrubRendition?.startTimeOffsetMs;
-
-      const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
-      if (signal.aborted) return undefined;
-
-      const input = new BufferedSeekingInput(arrayBuffer, {
-        videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
-        audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
-        startTimeOffsetMs,
-      });
-      return input;
-    },
-  });
-};

package/src/elements/EFMedia/videoTasks/makeScrubVideoSeekTask.ts

@@ -1,124 +0,0 @@
-import { Task } from "@lit/task";
-
-import type { VideoSample } from "mediabunny";
-
-import type { EFVideo } from "../../EFVideo";
-import { ScrubInputCache } from "./ScrubInputCache";
-
-type ScrubVideoSeekTask = Task<readonly [number], VideoSample | undefined>;
-
-// Shared cache instance across all scrub seek tasks
-const scrubInputCache = new ScrubInputCache();
-
-export const makeScrubVideoSeekTask = (host: EFVideo): ScrubVideoSeekTask => {
-  return new Task(host, {
-    args: () => [host.desiredSeekTimeMs] as const,
-    onError: (error) => {
-      console.error("scrubVideoSeekTask error", error);
-    },
-    onComplete: (_value) => {},
-    task: async ([desiredSeekTimeMs], { signal }) => {
-      signal.throwIfAborted();
-
-      const mediaEngine = host.mediaEngineTask.value;
-      if (!mediaEngine) {
-        return undefined;
-      }
-
-      // Get scrub rendition using the proper interface method
-      const scrubRendition = mediaEngine.getScrubVideoRendition();
-
-      if (!scrubRendition) {
-        return undefined; // No scrub rendition
-      }
-
-      const scrubRenditionWithSrc = {
-        ...scrubRendition,
-        src: mediaEngine.src,
-      };
-
-      // Compute which scrub segment (30s) contains the desired seek time
-      const segmentId = mediaEngine.computeSegmentId(
-        desiredSeekTimeMs,
-        scrubRenditionWithSrc,
-      );
-      if (segmentId === undefined) {
-        return undefined;
-      }
-
-      // Check if this scrub segment is cached (preloaded by scrub buffer task)
-      const isCached = mediaEngine.isSegmentCached(
-        segmentId,
-        scrubRenditionWithSrc,
-      );
-      if (!isCached) {
-        // Scrub content not preloaded - fail fast, let main video handle it
-        // Scrub's job is instant feedback from cached content only
-        return undefined;
-      }
-
-      signal.throwIfAborted();
-
-      try {
-        // Get or create BufferedSeekingInput for this scrub segment (30s)
-        // This efficiently reuses the same input for seeks within the same 30s range
-        const scrubInput = await scrubInputCache.getOrCreateInput(
-          segmentId,
-          async () => {
-            const [initSegment, mediaSegment] = await Promise.all([
-              mediaEngine.fetchInitSegment(scrubRenditionWithSrc, signal),
-              mediaEngine.fetchMediaSegment(segmentId, scrubRenditionWithSrc),
-            ]);
-
-            if (!initSegment || !mediaSegment || signal.aborted) {
-              return undefined;
-            }
-
-            const { BufferedSeekingInput } = await import(
-              "../BufferedSeekingInput.js"
-            );
-            const { EFMedia } = await import("../../EFMedia.js");
-
-            return new BufferedSeekingInput(
-              await new Blob([initSegment, mediaSegment]).arrayBuffer(),
-              {
-                videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
-                audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
-                startTimeOffsetMs: scrubRendition.startTimeOffsetMs,
-              },
-            );
-          },
-        );
-
-        if (!scrubInput) {
-          return undefined;
-        }
-
-        if (signal.aborted) {
-          return undefined;
-        }
-
-        // Get video track and seek to precise time within the 30s scrub segment
-        const videoTrack = await scrubInput.getFirstVideoTrack();
-        if (!videoTrack) {
-          return undefined;
-        }
-
-        if (signal.aborted) {
-          return undefined;
-        }
-
-        const sample = (await scrubInput.seek(
-          videoTrack.id,
-          desiredSeekTimeMs,
-        )) as unknown as VideoSample | undefined;
-
-        return sample;
-      } catch (error) {
-        if (signal.aborted) return undefined;
-        console.warn("Failed to get scrub video sample:", error);
-        return undefined;
-      }
-    },
-  });
-};

package/src/elements/EFMedia/videoTasks/makeScrubVideoSegmentFetchTask.ts

@@ -1,44 +0,0 @@
-import { Task } from "@lit/task";
-import type { MediaEngine } from "../../../transcoding/types";
-import type { EFVideo } from "../../EFVideo";
-import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
-
-export const makeScrubVideoSegmentFetchTask = (
-  host: EFVideo,
-): Task<
-  readonly [MediaEngine | undefined, number | undefined],
-  ArrayBuffer
-> => {
-  return new Task(host, {
-    args: () =>
-      [host.mediaEngineTask.value, host.scrubVideoSegmentIdTask.value] as const,
-    onError: (error) => {
-      console.error("scrubVideoSegmentFetchTask error", error);
-    },
-    onComplete: (_value) => {},
-    task: async (_, { signal }) => {
-      const mediaEngine = await getLatestMediaEngine(host, signal);
-      const segmentId = await host.scrubVideoSegmentIdTask.taskComplete;
-      if (segmentId === undefined) {
-        throw new Error("Scrub segment ID is not available for video");
-      }
-
-      // Get scrub rendition using the proper interface method
-      const scrubRendition = mediaEngine.getScrubVideoRendition();
-
-      if (!scrubRendition) {
-        // No scrub rendition available - this is fine, scrub is optional
-        throw new Error("No scrub rendition available");
-      }
-
-      return mediaEngine.fetchMediaSegment(
-        segmentId,
-        {
-          ...scrubRendition,
-          src: mediaEngine.src, // Ensure src is set
-        },
-        signal,
-      );
-    },
-  });
-};

package/src/elements/EFMedia/videoTasks/makeScrubVideoSegmentIdTask.ts

@@ -1,32 +0,0 @@
-import { Task } from "@lit/task";
-import type { MediaEngine } from "../../../transcoding/types";
-import type { EFVideo } from "../../EFVideo";
-import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
-
-export const makeScrubVideoSegmentIdTask = (
-  host: EFVideo,
-): Task<readonly [MediaEngine | undefined, number], number | undefined> => {
-  return new Task(host, {
-    args: () => [host.mediaEngineTask.value, host.desiredSeekTimeMs] as const,
-    onError: (error) => {
-      console.error("scrubVideoSegmentIdTask error", error);
-    },
-    onComplete: (_value) => {},
-    task: async ([, targetSeekTimeMs], { signal }) => {
-      const mediaEngine = await getLatestMediaEngine(host, signal);
-      signal.throwIfAborted(); // Abort if a new seek started
-
-      // Get scrub rendition using the proper interface method
-      const scrubRendition = mediaEngine.getScrubVideoRendition();
-
-      if (!scrubRendition) {
-        return undefined; // No scrub rendition available
-      }
-
-      return mediaEngine.computeSegmentId(targetSeekTimeMs, {
-        ...scrubRendition,
-        src: mediaEngine.src, // Ensure src is set
-      });
-    },
-  });
-};