@editframe/elements 0.24.1-beta.0 → 0.25.0-beta.0

package/dist/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.js

@@ -1,5 +1,7 @@
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.ts
 const makeAudioSegmentIdTask = (host) => {
 	return new Task(host, {
 		args: () => [host.mediaEngineTask.value, host.desiredSeekTimeMs],
@@ -16,4 +18,7 @@ const makeAudioSegmentIdTask = (host) => {
 		}
 	});
 };
+
+//#endregion
 export { makeAudioSegmentIdTask };
+//# sourceMappingURL=makeAudioSegmentIdTask.js.map

package/dist/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioSegmentIdTask.js","names":[],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\nimport type { MediaEngine } from \"../../../transcoding/types\";\nimport type { EFMedia } from \"../../EFMedia\";\nimport { getLatestMediaEngine } from \"../tasks/makeMediaEngineTask\";\n\nexport const makeAudioSegmentIdTask = (\n  host: EFMedia,\n): Task<readonly [MediaEngine | undefined, number], number | undefined> => {\n  return new Task(host, {\n    args: () => [host.mediaEngineTask.value, host.desiredSeekTimeMs] as const,\n    onError: (error) => {\n      console.error(\"audioSegmentIdTask error\", error);\n    },\n    onComplete: (_value) => {},\n    task: async ([, targetSeekTimeMs], { signal }) => {\n      const mediaEngine = await getLatestMediaEngine(host, signal);\n      signal.throwIfAborted();\n\n      const audioRendition = mediaEngine.getAudioRendition();\n\n      // Return undefined if no audio rendition available (video-only asset)\n      if (!audioRendition) {\n        return undefined;\n      }\n\n      return mediaEngine.computeSegmentId(targetSeekTimeMs, audioRendition);\n    },\n  });\n};\n"],"mappings":";;;;AAKA,MAAa,0BACX,SACyE;AACzE,QAAO,IAAI,KAAK,MAAM;EACpB,YAAY,CAAC,KAAK,gBAAgB,OAAO,KAAK,kBAAkB;EAChE,UAAU,UAAU;AAClB,WAAQ,MAAM,4BAA4B,MAAM;;EAElD,aAAa,WAAW;EACxB,MAAM,OAAO,GAAG,mBAAmB,EAAE,aAAa;GAChD,MAAM,cAAc,MAAM,qBAAqB,MAAM,OAAO;AAC5D,UAAO,gBAAgB;GAEvB,MAAM,iBAAiB,YAAY,mBAAmB;AAGtD,OAAI,CAAC,eACH;AAGF,UAAO,YAAY,iBAAiB,kBAAkB,eAAe;;EAExE,CAAC"}

package/dist/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.js

@@ -2,7 +2,9 @@ import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { LRUCache } from "../../../utils/LRUCache.js";
 import { IgnorableError } from "../../EFMedia.js";
 import { Task } from "@lit/task";
-var DECAY_WEIGHT = .8;
+
+//#region src/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.ts
+const DECAY_WEIGHT = .8;
 function makeAudioTimeDomainAnalysisTask(element) {
 	const cache = new LRUCache(1e3);
 	return new Task(element, {
@@ -107,4 +109,7 @@ function makeAudioTimeDomainAnalysisTask(element) {
 		}
 	});
 }
+
+//#endregion
 export { makeAudioTimeDomainAnalysisTask };
+//# sourceMappingURL=makeAudioTimeDomainAnalysisTask.js.map

package/dist/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioTimeDomainAnalysisTask.js","names":["audioContext: OfflineAudioContext"],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\n\nimport { EF_INTERACTIVE } from \"../../../EF_INTERACTIVE.js\";\nimport { LRUCache } from \"../../../utils/LRUCache.js\";\nimport { type EFMedia, IgnorableError } from \"../../EFMedia.js\";\n\n// DECAY_WEIGHT constant - same as original\nconst DECAY_WEIGHT = 0.8;\n\nexport function makeAudioTimeDomainAnalysisTask(element: EFMedia) {\n  // Internal cache for this task instance (same as original #byteTimeDomainCache)\n  const cache = new LRUCache<string, Uint8Array>(1000);\n\n  return new Task(element, {\n    autoRun: EF_INTERACTIVE,\n    onError: (error) => {\n      if (error instanceof IgnorableError) {\n        console.info(\"byteTimeDomainTask skipped: no audio track\");\n        return;\n      }\n      console.error(\"byteTimeDomainTask error\", error);\n    },\n    args: () =>\n      [\n        element.currentSourceTimeMs,\n        element.fftSize,\n        element.fftDecay,\n        element.fftGain,\n        element.shouldInterpolateFrequencies,\n      ] as const,\n    task: async (_, { signal }) => {\n      if (element.currentSourceTimeMs < 0) return null;\n\n      const currentTimeMs = element.currentSourceTimeMs;\n\n      // Calculate exact audio window needed based on fftDecay and frame timing\n      const frameIntervalMs = 1000 / 30; // 33.33ms per frame\n\n      // Need audio from earliest frame to current frame\n      const earliestFrameMs =\n        currentTimeMs - (element.fftDecay - 1) * frameIntervalMs;\n      const fromMs = Math.max(0, earliestFrameMs);\n      const maxToMs = currentTimeMs + frameIntervalMs; // Include current frame\n      const videoDurationMs = element.intrinsicDurationMs || 0;\n      const toMs =\n        videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;\n\n      // If the clamping results in an invalid range (seeking beyond the end), skip analysis silently\n      if (fromMs >= toMs) {\n        return null;\n      }\n\n      // Check cache early - before expensive audio fetching\n      // Use a preliminary cache key that doesn't depend on actual startOffsetMs from audio span\n      const preliminaryCacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${fromMs}:${currentTimeMs}`;\n      const cachedData = cache.get(preliminaryCacheKey);\n      if (cachedData) {\n        return cachedData;\n      }\n\n      const { fetchAudioSpanningTime: fetchAudioSpan } = await import(\n        \"../shared/AudioSpanUtils.ts\"\n      );\n      const audioSpan = await fetchAudioSpan(element, fromMs, toMs, signal);\n\n      if (!audioSpan || !audioSpan.blob) {\n        console.warn(\"Time domain analysis skipped: no audio data available\");\n        return null;\n      }\n\n      // Decode the real audio data\n      const tempAudioContext = new OfflineAudioContext(2, 48000, 48000);\n      const arrayBuffer = await audioSpan.blob.arrayBuffer();\n      const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);\n\n      // Use actual startOffset from audioSpan (relative to requested time)\n      const startOffsetMs = audioSpan.startMs;\n\n      // Process multiple frames with decay, similar to the reference code\n      const framesData = await Promise.all(\n        Array.from({ length: element.fftDecay }, async (_, frameIndex) => {\n          const frameOffset = frameIndex * (1000 / 30);\n          const startTime = Math.max(\n            0,\n            (currentTimeMs - frameOffset - startOffsetMs) / 1000,\n          );\n\n          const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;\n          const cachedFrame = cache.get(cacheKey);\n          if (cachedFrame) {\n            return cachedFrame;\n          }\n\n          let audioContext: OfflineAudioContext;\n          try {\n            audioContext = new OfflineAudioContext(2, 48000 * (1 / 30), 48000);\n          } catch (error) {\n            throw new Error(\n              `[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.`,\n            );\n          }\n\n          const source = audioContext.createBufferSource();\n          source.buffer = audioBuffer;\n\n          // Create analyzer for PCM data\n          const analyser = audioContext.createAnalyser();\n          analyser.fftSize = element.fftSize; // Ensure enough samples\n          analyser.minDecibels = -90;\n          analyser.maxDecibels = -20;\n\n          const gainNode = audioContext.createGain();\n          gainNode.gain.value = element.fftGain; // Amplify the signal\n\n          source.connect(gainNode);\n          gainNode.connect(analyser);\n          analyser.connect(audioContext.destination);\n\n          source.start(0, startTime, 1 / 30);\n\n          const dataLength = analyser.fftSize / 2;\n          try {\n            await audioContext.startRendering();\n            const frameData = new Uint8Array(dataLength);\n            analyser.getByteTimeDomainData(frameData);\n\n            // const points = frameData;\n            // Calculate RMS and midpoint values\n            const points = new Uint8Array(dataLength);\n            for (let i = 0; i < dataLength; i++) {\n              const pointSamples = frameData.slice(\n                i * (frameData.length / dataLength),\n                (i + 1) * (frameData.length / dataLength),\n              );\n\n              // Calculate RMS while preserving sign\n              const rms = Math.sqrt(\n                pointSamples.reduce((sum, sample) => {\n                  const normalized = (sample - 128) / 128;\n                  return sum + normalized * normalized;\n                }, 0) / pointSamples.length,\n              );\n\n              // Get average sign of the samples to determine direction\n              const avgSign = Math.sign(\n                pointSamples.reduce((sum, sample) => sum + (sample - 128), 0),\n              );\n\n              // Convert RMS back to byte range, preserving direction\n              points[i] = Math.min(255, Math.round(128 + avgSign * rms * 128));\n            }\n\n            cache.set(cacheKey, points);\n            return points;\n          } finally {\n            source.disconnect();\n            analyser.disconnect();\n          }\n        }),\n      );\n\n      // Combine frames with decay weighting\n      const frameLength = framesData[0]?.length ?? 0;\n      const smoothedData = new Uint8Array(frameLength);\n\n      for (let i = 0; i < frameLength; i++) {\n        let weightedSum = 0;\n        let weightSum = 0;\n\n        framesData.forEach((frame: Uint8Array, frameIndex: number) => {\n          const decayWeight = DECAY_WEIGHT ** frameIndex;\n          weightedSum += (frame[i] ?? 0) * decayWeight;\n          weightSum += decayWeight;\n        });\n\n        smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));\n      }\n\n      // Cache with the preliminary key so future requests can skip audio fetching\n      cache.set(preliminaryCacheKey, smoothedData);\n      return smoothedData;\n    },\n  });\n}\n"],"mappings":";;;;;;AAOA,MAAM,eAAe;AAErB,SAAgB,gCAAgC,SAAkB;CAEhE,MAAM,QAAQ,IAAI,SAA6B,IAAK;AAEpD,QAAO,IAAI,KAAK,SAAS;EACvB,SAAS;EACT,UAAU,UAAU;AAClB,OAAI,iBAAiB,gBAAgB;AACnC,YAAQ,KAAK,6CAA6C;AAC1D;;AAEF,WAAQ,MAAM,4BAA4B,MAAM;;EAElD,YACE;GACE,QAAQ;GACR,QAAQ;GACR,QAAQ;GACR,QAAQ;GACR,QAAQ;GACT;EACH,MAAM,OAAO,GAAG,EAAE,aAAa;AAC7B,OAAI,QAAQ,sBAAsB,EAAG,QAAO;GAE5C,MAAM,gBAAgB,QAAQ;GAG9B,MAAM,kBAAkB,MAAO;GAG/B,MAAM,kBACJ,iBAAiB,QAAQ,WAAW,KAAK;GAC3C,MAAM,SAAS,KAAK,IAAI,GAAG,gBAAgB;GAC3C,MAAM,UAAU,gBAAgB;GAChC,MAAM,kBAAkB,QAAQ,uBAAuB;GACvD,MAAM,OACJ,kBAAkB,IAAI,KAAK,IAAI,SAAS,gBAAgB,GAAG;AAG7D,OAAI,UAAU,KACZ,QAAO;GAKT,MAAM,sBAAsB,GAAG,QAAQ,6BAA6B,GAAG,QAAQ,QAAQ,GAAG,QAAQ,SAAS,GAAG,QAAQ,QAAQ,GAAG,OAAO,GAAG;GAC3I,MAAM,aAAa,MAAM,IAAI,oBAAoB;AACjD,OAAI,WACF,QAAO;GAGT,MAAM,EAAE,wBAAwB,mBAAmB,MAAM,OACvD;GAEF,MAAM,YAAY,MAAM,eAAe,SAAS,QAAQ,MAAM,OAAO;AAErE,OAAI,CAAC,aAAa,CAAC,UAAU,MAAM;AACjC,YAAQ,KAAK,wDAAwD;AACrE,WAAO;;GAIT,MAAM,mBAAmB,IAAI,oBAAoB,GAAG,MAAO,KAAM;GACjE,MAAM,cAAc,MAAM,UAAU,KAAK,aAAa;GACtD,MAAM,cAAc,MAAM,iBAAiB,gBAAgB,YAAY;GAGvE,MAAM,gBAAgB,UAAU;GAGhC,MAAM,aAAa,MAAM,QAAQ,IAC/B,MAAM,KAAK,EAAE,QAAQ,QAAQ,UAAU,EAAE,OAAO,KAAG,eAAe;IAChE,MAAM,cAAc,cAAc,MAAO;IACzC,MAAM,YAAY,KAAK,IACrB,IACC,gBAAgB,cAAc,iBAAiB,IACjD;IAED,MAAM,WAAW,GAAG,QAAQ,6BAA6B,GAAG,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,GAAG,cAAc,GAAG;IACnH,MAAM,cAAc,MAAM,IAAI,SAAS;AACvC,QAAI,YACF,QAAO;IAGT,IAAIA;AACJ,QAAI;AACF,oBAAe,IAAI,oBAAoB,GAAG,QAAS,IAAI,KAAK,KAAM;aAC3D,OAAO;AACd,WAAM,IAAI,MACR,wEAAwE,QAAS,IAAI,IAAI,qBAAqB,WAAW,WAAW,UAAU,KAAK,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,CAAC,2CAC3M;;IAGH,MAAM,SAAS,aAAa,oBAAoB;AAChD,WAAO,SAAS;IAGhB,MAAM,WAAW,aAAa,gBAAgB;AAC9C,aAAS,UAAU,QAAQ;AAC3B,aAAS,cAAc;AACvB,aAAS,cAAc;IAEvB,MAAM,WAAW,aAAa,YAAY;AAC1C,aAAS,KAAK,QAAQ,QAAQ;AAE9B,WAAO,QAAQ,SAAS;AACxB,aAAS,QAAQ,SAAS;AAC1B,aAAS,QAAQ,aAAa,YAAY;AAE1C,WAAO,MAAM,GAAG,WAAW,IAAI,GAAG;IAElC,MAAM,aAAa,SAAS,UAAU;AACtC,QAAI;AACF,WAAM,aAAa,gBAAgB;KACnC,MAAM,YAAY,IAAI,WAAW,WAAW;AAC5C,cAAS,sBAAsB,UAAU;KAIzC,MAAM,SAAS,IAAI,WAAW,WAAW;AACzC,UAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAAK;MACnC,MAAM,eAAe,UAAU,MAC7B,KAAK,UAAU,SAAS,cACvB,IAAI,MAAM,UAAU,SAAS,YAC/B;MAGD,MAAM,MAAM,KAAK,KACf,aAAa,QAAQ,KAAK,WAAW;OACnC,MAAM,cAAc,SAAS,OAAO;AACpC,cAAO,MAAM,aAAa;SACzB,EAAE,GAAG,aAAa,OACtB;MAGD,MAAM,UAAU,KAAK,KACnB,aAAa,QAAQ,KAAK,WAAW,OAAO,SAAS,MAAM,EAAE,CAC9D;AAGD,aAAO,KAAK,KAAK,IAAI,KAAK,KAAK,MAAM,MAAM,UAAU,MAAM,IAAI,CAAC;;AAGlE,WAAM,IAAI,UAAU,OAAO;AAC3B,YAAO;cACC;AACR,YAAO,YAAY;AACnB,cAAS,YAAY;;KAEvB,CACH;GAGD,MAAM,cAAc,WAAW,IAAI,UAAU;GAC7C,MAAM,eAAe,IAAI,WAAW,YAAY;AAEhD,QAAK,IAAI,IAAI,GAAG,IAAI,aAAa,KAAK;IACpC,IAAI,cAAc;IAClB,IAAI,YAAY;AAEhB,eAAW,SAAS,OAAmB,eAAuB;KAC5D,MAAM,cAAc,gBAAgB;AACpC,qBAAgB,MAAM,MAAM,KAAK;AACjC,kBAAa;MACb;AAEF,iBAAa,KAAK,KAAK,IAAI,KAAK,KAAK,MAAM,cAAc,UAAU,CAAC;;AAItE,SAAM,IAAI,qBAAqB,aAAa;AAC5C,UAAO;;EAEV,CAAC"}

package/dist/elements/EFMedia/shared/AudioSpanUtils.js

@@ -1,4 +1,9 @@
-var fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
+//#region src/elements/EFMedia/shared/AudioSpanUtils.ts
+/**
+* Fetch audio segment data using MediaEngine
+* Pure function with explicit dependencies
+*/
+const fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
 	const audioRendition = mediaEngine.audioRendition;
 	if (!audioRendition) throw new Error("Audio rendition not available");
 	const segmentData = /* @__PURE__ */ new Map();
@@ -10,10 +15,18 @@ var fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
 	for (const [segmentId, arrayBuffer] of fetchedSegments) segmentData.set(segmentId, arrayBuffer);
 	return segmentData;
 };
-var createAudioSpanBlob = (initSegment, mediaSegments) => {
+/**
+* Create audio span blob from init segment and media segments
+* Pure function for blob creation
+*/
+const createAudioSpanBlob = (initSegment, mediaSegments) => {
 	const chunks = [initSegment, ...mediaSegments];
 	return new Blob(chunks, { type: "audio/mp4" });
 };
+/**
+* Fetch audio spanning a time range
+* Main function that orchestrates segment calculation, fetching, and blob creation
+*/
 const fetchAudioSpanningTime = async (host, fromMs, toMs, signal) => {
 	if (fromMs >= toMs || fromMs < 0) throw new Error(`Invalid time range: fromMs=${fromMs}, toMs=${toMs}`);
 	const mediaEngine = await host.mediaEngineTask.taskComplete;
@@ -35,4 +48,7 @@ const fetchAudioSpanningTime = async (host, fromMs, toMs, signal) => {
 		blob
 	};
 };
+
+//#endregion
 export { fetchAudioSpanningTime };
+//# sourceMappingURL=AudioSpanUtils.js.map

package/dist/elements/EFMedia/shared/AudioSpanUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioSpanUtils.js","names":[],"sources":["../../../../src/elements/EFMedia/shared/AudioSpanUtils.ts"],"sourcesContent":["import type {\n  AudioSpan,\n  MediaEngine,\n  SegmentTimeRange,\n} from \"../../../transcoding/types\";\nimport type { EFMedia } from \"../../EFMedia\";\n\n/**\n * Fetch audio segment data using MediaEngine\n * Pure function with explicit dependencies\n */\nconst fetchAudioSegmentData = async (\n  segmentIds: number[],\n  mediaEngine: MediaEngine,\n  signal: AbortSignal,\n): Promise<Map<number, ArrayBuffer>> => {\n  const audioRendition = mediaEngine.audioRendition;\n  if (!audioRendition) {\n    throw new Error(\"Audio rendition not available\");\n  }\n\n  const segmentData = new Map<number, ArrayBuffer>();\n\n  // Fetch all segments - MediaEngine handles deduplication internally\n  const fetchPromises = segmentIds.map(async (segmentId) => {\n    const arrayBuffer = await mediaEngine.fetchMediaSegment(\n      segmentId,\n      audioRendition,\n      signal,\n    );\n    return [segmentId, arrayBuffer] as [number, ArrayBuffer];\n  });\n\n  const fetchedSegments = await Promise.all(fetchPromises);\n  signal.throwIfAborted();\n\n  for (const [segmentId, arrayBuffer] of fetchedSegments) {\n    segmentData.set(segmentId, arrayBuffer);\n  }\n\n  return segmentData;\n};\n\n/**\n * Create audio span blob from init segment and media segments\n * Pure function for blob creation\n */\nconst createAudioSpanBlob = (\n  initSegment: ArrayBuffer,\n  mediaSegments: ArrayBuffer[],\n): Blob => {\n  const chunks = [initSegment, ...mediaSegments];\n  return new Blob(chunks, { type: \"audio/mp4\" });\n};\n\n/**\n * Fetch audio spanning a time range\n * Main function that orchestrates segment calculation, fetching, and blob creation\n */\nexport const fetchAudioSpanningTime = async (\n  host: EFMedia,\n  fromMs: number,\n  toMs: number,\n  signal: AbortSignal,\n): Promise<AudioSpan | undefined> => {\n  // Validate inputs\n  if (fromMs >= toMs || fromMs < 0) {\n    throw new Error(`Invalid time range: fromMs=${fromMs}, toMs=${toMs}`);\n  }\n\n  // Get dependencies from host\n  const mediaEngine = await host.mediaEngineTask.taskComplete;\n  const initSegment = await host.audioInitSegmentFetchTask.taskComplete;\n\n  // Return undefined if no audio rendition available\n  if (!mediaEngine?.audioRendition) {\n    return undefined;\n  }\n\n  if (!initSegment) {\n    return undefined;\n  }\n\n  // Calculate segments needed using the media engine's method\n  const segmentRanges = mediaEngine.calculateAudioSegmentRange(\n    fromMs,\n    toMs,\n    mediaEngine.audioRendition,\n    host.intrinsicDurationMs || 10000,\n  );\n\n  if (segmentRanges.length === 0) {\n    throw new Error(`No segments found for time range ${fromMs}-${toMs}ms`);\n  }\n\n  // Fetch segment data\n  const segmentIds = segmentRanges.map((r: SegmentTimeRange) => r.segmentId);\n  const segmentData = await fetchAudioSegmentData(\n    segmentIds,\n    mediaEngine,\n    signal,\n  );\n\n  // Create ordered array of segments\n  const orderedSegments = segmentIds.map((id: number) => {\n    const segment = segmentData.get(id);\n    if (!segment) {\n      throw new Error(`Missing segment data for segment ID ${id}`);\n    }\n    return segment;\n  });\n\n  // Create blob\n  const blob = createAudioSpanBlob(initSegment, orderedSegments);\n\n  // Calculate actual time boundaries\n  const actualStartMs = Math.min(\n    ...segmentRanges.map((r: SegmentTimeRange) => r.startMs),\n  );\n  const actualEndMs = Math.max(\n    ...segmentRanges.map((r: SegmentTimeRange) => r.endMs),\n  );\n\n  return {\n    startMs: actualStartMs,\n    endMs: actualEndMs,\n    blob,\n  };\n};\n"],"mappings":";;;;;AAWA,MAAM,wBAAwB,OAC5B,YACA,aACA,WACsC;CACtC,MAAM,iBAAiB,YAAY;AACnC,KAAI,CAAC,eACH,OAAM,IAAI,MAAM,gCAAgC;CAGlD,MAAM,8BAAc,IAAI,KAA0B;CAGlD,MAAM,gBAAgB,WAAW,IAAI,OAAO,cAAc;AAMxD,SAAO,CAAC,WALY,MAAM,YAAY,kBACpC,WACA,gBACA,OACD,CAC8B;GAC/B;CAEF,MAAM,kBAAkB,MAAM,QAAQ,IAAI,cAAc;AACxD,QAAO,gBAAgB;AAEvB,MAAK,MAAM,CAAC,WAAW,gBAAgB,gBACrC,aAAY,IAAI,WAAW,YAAY;AAGzC,QAAO;;;;;;AAOT,MAAM,uBACJ,aACA,kBACS;CACT,MAAM,SAAS,CAAC,aAAa,GAAG,cAAc;AAC9C,QAAO,IAAI,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;;;;;;AAOhD,MAAa,yBAAyB,OACpC,MACA,QACA,MACA,WACmC;AAEnC,KAAI,UAAU,QAAQ,SAAS,EAC7B,OAAM,IAAI,MAAM,8BAA8B,OAAO,SAAS,OAAO;CAIvE,MAAM,cAAc,MAAM,KAAK,gBAAgB;CAC/C,MAAM,cAAc,MAAM,KAAK,0BAA0B;AAGzD,KAAI,CAAC,aAAa,eAChB;AAGF,KAAI,CAAC,YACH;CAIF,MAAM,gBAAgB,YAAY,2BAChC,QACA,MACA,YAAY,gBACZ,KAAK,uBAAuB,IAC7B;AAED,KAAI,cAAc,WAAW,EAC3B,OAAM,IAAI,MAAM,oCAAoC,OAAO,GAAG,KAAK,IAAI;CAIzE,MAAM,aAAa,cAAc,KAAK,MAAwB,EAAE,UAAU;CAC1E,MAAM,cAAc,MAAM,sBACxB,YACA,aACA,OACD;CAYD,MAAM,OAAO,oBAAoB,aATT,WAAW,KAAK,OAAe;EACrD,MAAM,UAAU,YAAY,IAAI,GAAG;AACnC,MAAI,CAAC,QACH,OAAM,IAAI,MAAM,uCAAuC,KAAK;AAE9D,SAAO;GACP,CAG4D;AAU9D,QAAO;EACL,SARoB,KAAK,IACzB,GAAG,cAAc,KAAK,MAAwB,EAAE,QAAQ,CACzD;EAOC,OANkB,KAAK,IACvB,GAAG,cAAc,KAAK,MAAwB,EAAE,MAAM,CACvD;EAKC;EACD"}

package/dist/elements/EFMedia/shared/BufferUtils.d.ts

@@ -1,71 +1,13 @@
-import { AudioRendition, VideoRendition } from '../../../transcoding/types';
+//#region src/elements/EFMedia/shared/BufferUtils.d.ts
 /**
  * State interface for media buffering - orchestration only, no data storage
  */
-export interface MediaBufferState {
-    currentSeekTimeMs: number;
-    requestedSegments: Set<number>;
-    activeRequests: Set<number>;
-    requestQueue: number[];
+interface MediaBufferState {
+  currentSeekTimeMs: number;
+  requestedSegments: Set<number>;
+  activeRequests: Set<number>;
+  requestQueue: number[];
 }
-/**
- * Configuration interface for media buffering - generic for both audio and video
- */
-export interface MediaBufferConfig {
-    bufferDurationMs: number;
-    maxParallelFetches: number;
-    enableBuffering: boolean;
-    enableContinuousBuffering?: boolean;
-}
-/**
- * Dependencies interface for media buffering - integrates with BaseMediaEngine
- */
-export interface MediaBufferDependencies<T extends AudioRendition | VideoRendition> {
-    computeSegmentId: (timeMs: number, rendition: T) => Promise<number | undefined>;
-    prefetchSegment: (segmentId: number, rendition: T) => Promise<void>;
-    isSegmentCached: (segmentId: number, rendition: T) => boolean;
-    getRendition: () => Promise<T | undefined>;
-    logError: (message: string, error: any) => void;
-}
-/**
- * Compute segment range for a time window
- * Pure function - determines which segments are needed for a time range
- */
-export declare const computeSegmentRange: <T extends AudioRendition | VideoRendition>(startTimeMs: number, endTimeMs: number, rendition: T, computeSegmentId: (timeMs: number, rendition: T) => number | undefined) => number[];
-/**
- * Async version of computeSegmentRange for when computeSegmentId is async
- */
-export declare const computeSegmentRangeAsync: <T extends AudioRendition | VideoRendition>(startTimeMs: number, endTimeMs: number, durationMs: number, rendition: T, computeSegmentId: (timeMs: number, rendition: T) => Promise<number | undefined>) => Promise<number[]>;
-/**
- * Compute buffer queue based on desired segments and what we've already requested
- * Pure function - determines what new segments should be prefetched
- */
-export declare const computeBufferQueue: (desiredSegments: number[], requestedSegments: Set<number>) => number[];
-/**
- * Handle seek time change and recompute buffer queue
- * Pure function - computes new queue when seek time changes
- */
-export declare const handleSeekTimeChange: <T extends AudioRendition | VideoRendition>(newSeekTimeMs: number, bufferDurationMs: number, rendition: T, currentState: MediaBufferState, computeSegmentId: (timeMs: number, rendition: T) => number | undefined) => {
-    newQueue: number[];
-    overlappingRequests: number[];
-};
-/**
- * Check if a segment has been requested for buffering
- * Pure function for checking buffer orchestration state
- */
-export declare const isSegmentRequested: (segmentId: number, bufferState: MediaBufferState | undefined) => boolean;
-/**
- * Get requested segments from a list of segment IDs
- * Pure function that returns which segments have been requested for buffering
- */
-export declare const getRequestedSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => Set<number>;
-/**
- * Get unrequested segments from a list of segment IDs
- * Pure function that returns which segments haven't been requested yet
- */
-export declare const getUnrequestedSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => number[];
-/**
- * Core media buffering orchestration logic - prefetch only, no data storage
- * Integrates with BaseMediaEngine's existing caching and request deduplication
- */
-export declare const manageMediaBuffer: <T extends AudioRendition | VideoRendition>(seekTimeMs: number, config: MediaBufferConfig, currentState: MediaBufferState, durationMs: number, signal: AbortSignal, deps: MediaBufferDependencies<T>) => Promise<MediaBufferState>;
+//#endregion
+export { MediaBufferState };
+//# sourceMappingURL=BufferUtils.d.ts.map

package/dist/elements/EFMedia/shared/BufferUtils.js

@@ -1,3 +1,7 @@
+//#region src/elements/EFMedia/shared/BufferUtils.ts
+/**
+* Async version of computeSegmentRange for when computeSegmentId is async
+*/
 const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rendition, computeSegmentId) => {
 	const segments = [];
 	const segmentDurationMs = rendition.segmentDurationMs || 1e3;
@@ -12,9 +16,17 @@ const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rend
 	}
 	return segments.filter((id, index, arr) => arr.indexOf(id) === index);
 };
+/**
+* Compute buffer queue based on desired segments and what we've already requested
+* Pure function - determines what new segments should be prefetched
+*/
 const computeBufferQueue = (desiredSegments, requestedSegments) => {
 	return desiredSegments.filter((segmentId) => !requestedSegments.has(segmentId));
 };
+/**
+* Core media buffering orchestration logic - prefetch only, no data storage
+* Integrates with BaseMediaEngine's existing caching and request deduplication
+*/
 const manageMediaBuffer = async (seekTimeMs, config, currentState, durationMs, signal, deps) => {
 	if (!config.enableBuffering) return currentState;
 	const rendition = await deps.getRendition();
@@ -53,4 +65,7 @@ const manageMediaBuffer = async (seekTimeMs, config, currentState, durationMs, s
 		requestQueue: remainingQueue
 	};
 };
+
+//#endregion
 export { manageMediaBuffer };
+//# sourceMappingURL=BufferUtils.js.map

package/dist/elements/EFMedia/shared/BufferUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferUtils.js","names":["segments: number[]"],"sources":["../../../../src/elements/EFMedia/shared/BufferUtils.ts"],"sourcesContent":["import type {\n  AudioRendition,\n  VideoRendition,\n} from \"../../../transcoding/types\";\n\n/**\n * State interface for media buffering - orchestration only, no data storage\n */\nexport interface MediaBufferState {\n  currentSeekTimeMs: number;\n  requestedSegments: Set<number>; // Segments we've requested for buffering\n  activeRequests: Set<number>; // Segments currently being fetched\n  requestQueue: number[]; // Segments queued to be requested\n}\n\n/**\n * Configuration interface for media buffering - generic for both audio and video\n */\nexport interface MediaBufferConfig {\n  bufferDurationMs: number;\n  maxParallelFetches: number;\n  enableBuffering: boolean;\n  enableContinuousBuffering?: boolean;\n}\n\n/**\n * Dependencies interface for media buffering - integrates with BaseMediaEngine\n */\nexport interface MediaBufferDependencies<\n  T extends AudioRendition | VideoRendition,\n> {\n  computeSegmentId: (\n    timeMs: number,\n    rendition: T,\n  ) => Promise<number | undefined>;\n  prefetchSegment: (segmentId: number, rendition: T) => Promise<void>; // Just trigger prefetch, don't return data\n  isSegmentCached: (segmentId: number, rendition: T) => boolean; // Check BaseMediaEngine cache\n  getRendition: () => Promise<T | undefined>;\n  logError: (message: string, error: any) => void;\n}\n\n/**\n * Compute segment range for a time window\n * Pure function - determines which segments are needed for a time range\n */\nexport const computeSegmentRange = <T extends AudioRendition | VideoRendition>(\n  startTimeMs: number,\n  endTimeMs: number,\n  rendition: T,\n  computeSegmentId: (timeMs: number, rendition: T) => number | undefined,\n): number[] => {\n  const segments: number[] = [];\n  const segmentDurationMs = (rendition as any).segmentDurationMs || 1000;\n\n  // Calculate segment indices that overlap with [startTimeMs, endTimeMs]\n  const startSegmentIndex = Math.floor(startTimeMs / segmentDurationMs);\n  const endSegmentIndex = Math.floor(endTimeMs / segmentDurationMs);\n\n  for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {\n    const segmentId = computeSegmentId(i * segmentDurationMs, rendition);\n    if (segmentId !== undefined) {\n      segments.push(segmentId);\n    }\n  }\n\n  return segments.filter((id, index, arr) => arr.indexOf(id) === index); // Remove duplicates\n};\n\n/**\n * Async version of computeSegmentRange for when computeSegmentId is async\n */\nexport const computeSegmentRangeAsync = async <\n  T extends AudioRendition | VideoRendition,\n>(\n  startTimeMs: number,\n  endTimeMs: number,\n  durationMs: number,\n  rendition: T,\n  computeSegmentId: (\n    timeMs: number,\n    rendition: T,\n  ) => Promise<number | undefined>,\n): Promise<number[]> => {\n  const segments: number[] = [];\n  const segmentDurationMs = (rendition as any).segmentDurationMs || 1000;\n\n  // Calculate segment indices that overlap with [startTimeMs, endTimeMs]\n  const startSegmentIndex = Math.floor(startTimeMs / segmentDurationMs);\n  const endSegmentIndex = Math.floor(\n    Math.min(endTimeMs, durationMs) / segmentDurationMs,\n  );\n\n  for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {\n    const timeMs = i * segmentDurationMs;\n    if (timeMs < durationMs) {\n      const segmentId = await computeSegmentId(timeMs, rendition);\n      if (segmentId !== undefined) {\n        segments.push(segmentId);\n      }\n    }\n  }\n\n  return segments.filter((id, index, arr) => arr.indexOf(id) === index); // Remove duplicates\n};\n\n/**\n * Compute buffer queue based on desired segments and what we've already requested\n * Pure function - determines what new segments should be prefetched\n */\nexport const computeBufferQueue = (\n  desiredSegments: number[],\n  requestedSegments: Set<number>,\n): number[] => {\n  return desiredSegments.filter(\n    (segmentId) => !requestedSegments.has(segmentId),\n  );\n};\n\n/**\n * Handle seek time change and recompute buffer queue\n * Pure function - computes new queue when seek time changes\n */\nexport const handleSeekTimeChange = <T extends AudioRendition | VideoRendition>(\n  newSeekTimeMs: number,\n  bufferDurationMs: number,\n  rendition: T,\n  currentState: MediaBufferState,\n  computeSegmentId: (timeMs: number, rendition: T) => number | undefined,\n): { newQueue: number[]; overlappingRequests: number[] } => {\n  const endTimeMs = newSeekTimeMs + bufferDurationMs;\n  const desiredSegments = computeSegmentRange(\n    newSeekTimeMs,\n    endTimeMs,\n    rendition,\n    computeSegmentId,\n  );\n\n  // Find segments that are already being requested\n  const overlappingRequests = desiredSegments.filter((segmentId) =>\n    currentState.requestedSegments.has(segmentId),\n  );\n\n  const newQueue = computeBufferQueue(\n    desiredSegments,\n    currentState.requestedSegments,\n  );\n\n  return { newQueue, overlappingRequests };\n};\n\n/**\n * Check if a segment has been requested for buffering\n * Pure function for checking buffer orchestration state\n */\nexport const isSegmentRequested = (\n  segmentId: number,\n  bufferState: MediaBufferState | undefined,\n): boolean => {\n  return bufferState?.requestedSegments.has(segmentId) ?? false;\n};\n\n/**\n * Get requested segments from a list of segment IDs\n * Pure function that returns which segments have been requested for buffering\n */\nexport const getRequestedSegments = (\n  segmentIds: number[],\n  bufferState: MediaBufferState | undefined,\n): Set<number> => {\n  if (!bufferState) {\n    return new Set();\n  }\n  return new Set(\n    segmentIds.filter((id) => bufferState.requestedSegments.has(id)),\n  );\n};\n\n/**\n * Get unrequested segments from a list of segment IDs\n * Pure function that returns which segments haven't been requested yet\n */\nexport const getUnrequestedSegments = (\n  segmentIds: number[],\n  bufferState: MediaBufferState | undefined,\n): number[] => {\n  if (!bufferState) {\n    return segmentIds;\n  }\n  return segmentIds.filter((id) => !bufferState.requestedSegments.has(id));\n};\n\n/**\n * Core media buffering orchestration logic - prefetch only, no data storage\n * Integrates with BaseMediaEngine's existing caching and request deduplication\n */\nexport const manageMediaBuffer = async <\n  T extends AudioRendition | VideoRendition,\n>(\n  seekTimeMs: number,\n  config: MediaBufferConfig,\n  currentState: MediaBufferState,\n  durationMs: number,\n  signal: AbortSignal,\n  deps: MediaBufferDependencies<T>,\n): Promise<MediaBufferState> => {\n  if (!config.enableBuffering) {\n    return currentState;\n  }\n\n  const rendition = await deps.getRendition();\n  if (!rendition) {\n    // Cannot buffer without a rendition\n    return currentState;\n  }\n  const endTimeMs = seekTimeMs + config.bufferDurationMs;\n\n  const desiredSegments = await computeSegmentRangeAsync(\n    seekTimeMs,\n    endTimeMs,\n    durationMs,\n    rendition,\n    deps.computeSegmentId,\n  );\n  // Filter out segments already cached by BaseMediaEngine\n  const uncachedSegments = desiredSegments.filter(\n    (segmentId) => !deps.isSegmentCached(segmentId, rendition),\n  );\n\n  const newQueue = computeBufferQueue(\n    uncachedSegments,\n    currentState.requestedSegments,\n  );\n\n  // Shared state for concurrency control - prevents race conditions\n  const newRequestedSegments = new Set(currentState.requestedSegments);\n  const newActiveRequests = new Set(currentState.activeRequests);\n  const remainingQueue = [...newQueue];\n\n  // Thread-safe function to start next segment when slot becomes available\n  const startNextSegment = (): void => {\n    // Check if we have capacity and segments to fetch\n    if (\n      newActiveRequests.size >= config.maxParallelFetches ||\n      remainingQueue.length === 0 ||\n      signal.aborted\n    ) {\n      return;\n    }\n\n    const nextSegmentId = remainingQueue.shift();\n    if (nextSegmentId === undefined) return;\n\n    // Skip if already requested or now cached\n    if (\n      newRequestedSegments.has(nextSegmentId) ||\n      deps.isSegmentCached(nextSegmentId, rendition)\n    ) {\n      startNextSegment(); // Try next segment immediately\n      return;\n    }\n\n    newRequestedSegments.add(nextSegmentId);\n    newActiveRequests.add(nextSegmentId);\n\n    // Start the prefetch request\n    deps\n      .prefetchSegment(nextSegmentId, rendition)\n      .then(() => {\n        if (signal.aborted) return;\n        newActiveRequests.delete(nextSegmentId);\n        // Start next segment if continuous buffering is enabled\n        if (config.enableContinuousBuffering ?? true) {\n          startNextSegment();\n        }\n      })\n      .catch((error) => {\n        if (signal.aborted) return;\n        newActiveRequests.delete(nextSegmentId);\n        deps.logError(`Failed to prefetch segment ${nextSegmentId}`, error);\n        // Continue even after error if continuous buffering is enabled\n        if (config.enableContinuousBuffering ?? true) {\n          startNextSegment();\n        }\n      });\n  };\n\n  // Start initial batch of requests up to maxParallelFetches limit\n  const initialBatchSize = Math.min(config.maxParallelFetches, newQueue.length);\n  for (let i = 0; i < initialBatchSize; i++) {\n    startNextSegment();\n  }\n\n  const result = {\n    currentSeekTimeMs: seekTimeMs,\n    requestedSegments: newRequestedSegments,\n    activeRequests: newActiveRequests,\n    requestQueue: remainingQueue, // What's left in the queue\n  };\n  return result;\n};\n"],"mappings":";;;;AAuEA,MAAa,2BAA2B,OAGtC,aACA,WACA,YACA,WACA,qBAIsB;CACtB,MAAMA,WAAqB,EAAE;CAC7B,MAAM,oBAAqB,UAAkB,qBAAqB;CAGlE,MAAM,oBAAoB,KAAK,MAAM,cAAc,kBAAkB;CACrE,MAAM,kBAAkB,KAAK,MAC3B,KAAK,IAAI,WAAW,WAAW,GAAG,kBACnC;AAED,MAAK,IAAI,IAAI,mBAAmB,KAAK,iBAAiB,KAAK;EACzD,MAAM,SAAS,IAAI;AACnB,MAAI,SAAS,YAAY;GACvB,MAAM,YAAY,MAAM,iBAAiB,QAAQ,UAAU;AAC3D,OAAI,cAAc,OAChB,UAAS,KAAK,UAAU;;;AAK9B,QAAO,SAAS,QAAQ,IAAI,OAAO,QAAQ,IAAI,QAAQ,GAAG,KAAK,MAAM;;;;;;AAOvE,MAAa,sBACX,iBACA,sBACa;AACb,QAAO,gBAAgB,QACpB,cAAc,CAAC,kBAAkB,IAAI,UAAU,CACjD;;;;;;AAgFH,MAAa,oBAAoB,OAG/B,YACA,QACA,cACA,YACA,QACA,SAC8B;AAC9B,KAAI,CAAC,OAAO,gBACV,QAAO;CAGT,MAAM,YAAY,MAAM,KAAK,cAAc;AAC3C,KAAI,CAAC,UAEH,QAAO;CAgBT,MAAM,WAAW,oBAZO,MAAM,yBAC5B,YAHgB,aAAa,OAAO,kBAKpC,YACA,WACA,KAAK,iBACN,EAEwC,QACtC,cAAc,CAAC,KAAK,gBAAgB,WAAW,UAAU,CAC3D,EAIC,aAAa,kBACd;CAGD,MAAM,uBAAuB,IAAI,IAAI,aAAa,kBAAkB;CACpE,MAAM,oBAAoB,IAAI,IAAI,aAAa,eAAe;CAC9D,MAAM,iBAAiB,CAAC,GAAG,SAAS;CAGpC,MAAM,yBAA+B;AAEnC,MACE,kBAAkB,QAAQ,OAAO,sBACjC,eAAe,WAAW,KAC1B,OAAO,QAEP;EAGF,MAAM,gBAAgB,eAAe,OAAO;AAC5C,MAAI,kBAAkB,OAAW;AAGjC,MACE,qBAAqB,IAAI,cAAc,IACvC,KAAK,gBAAgB,eAAe,UAAU,EAC9C;AACA,qBAAkB;AAClB;;AAGF,uBAAqB,IAAI,cAAc;AACvC,oBAAkB,IAAI,cAAc;AAGpC,OACG,gBAAgB,eAAe,UAAU,CACzC,WAAW;AACV,OAAI,OAAO,QAAS;AACpB,qBAAkB,OAAO,cAAc;AAEvC,OAAI,OAAO,6BAA6B,KACtC,mBAAkB;IAEpB,CACD,OAAO,UAAU;AAChB,OAAI,OAAO,QAAS;AACpB,qBAAkB,OAAO,cAAc;AACvC,QAAK,SAAS,8BAA8B,iBAAiB,MAAM;AAEnE,OAAI,OAAO,6BAA6B,KACtC,mBAAkB;IAEpB;;CAIN,MAAM,mBAAmB,KAAK,IAAI,OAAO,oBAAoB,SAAS,OAAO;AAC7E,MAAK,IAAI,IAAI,GAAG,IAAI,kBAAkB,IACpC,mBAAkB;AASpB,QANe;EACb,mBAAmB;EACnB,mBAAmB;EACnB,gBAAgB;EAChB,cAAc;EACf"}

package/dist/elements/EFMedia/shared/GlobalInputCache.js

@@ -1,26 +1,52 @@
 import { LRUCache } from "../../../utils/LRUCache.js";
+
+//#region src/elements/EFMedia/shared/GlobalInputCache.ts
+/**
+* Global cache for MediaBunny Input instances
+* Shared across all MediaEngine instances to prevent duplicate decoding
+* of the same segment data
+*/
 var GlobalInputCache = class {
 	constructor() {
 		this.cache = new LRUCache(50);
 	}
+	/**
+	* Generate standardized cache key for Input objects
+	* Format: "input:{src}:{segmentId}:{renditionId}"
+	*/
 	generateKey(src, segmentId, renditionId) {
 		return `input:${src}:${segmentId}:${renditionId || "default"}`;
 	}
+	/**
+	* Get cached Input object
+	*/
 	get(src, segmentId, renditionId) {
 		const key = this.generateKey(src, segmentId, renditionId);
 		return this.cache.get(key);
 	}
+	/**
+	* Cache Input object
+	*/
 	set(src, segmentId, input, renditionId) {
 		const key = this.generateKey(src, segmentId, renditionId);
 		this.cache.set(key, input);
 	}
+	/**
+	* Check if Input is cached
+	*/
 	has(src, segmentId, renditionId) {
 		const key = this.generateKey(src, segmentId, renditionId);
 		return this.cache.has(key);
 	}
+	/**
+	* Clear all cached Input objects
+	*/
 	clear() {
 		this.cache.clear();
 	}
+	/**
+	* Get cache statistics for debugging
+	*/
 	getStats() {
 		return {
 			size: this.cache.size,
@@ -30,4 +56,7 @@ var GlobalInputCache = class {
 };
 const globalInputCache = new GlobalInputCache();
 globalThis.debugInputCache = globalInputCache;
+
+//#endregion
 export { globalInputCache };
+//# sourceMappingURL=GlobalInputCache.js.map

package/dist/elements/EFMedia/shared/GlobalInputCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalInputCache.js","names":[],"sources":["../../../../src/elements/EFMedia/shared/GlobalInputCache.ts"],"sourcesContent":["import type { Input } from \"mediabunny\";\nimport { LRUCache } from \"../../../utils/LRUCache.js\";\n\n/**\n * Global cache for MediaBunny Input instances\n * Shared across all MediaEngine instances to prevent duplicate decoding\n * of the same segment data\n */\nclass GlobalInputCache {\n  private cache = new LRUCache<string, Input>(50); // 50 Input instances max\n\n  /**\n   * Generate standardized cache key for Input objects\n   * Format: \"input:{src}:{segmentId}:{renditionId}\"\n   */\n  private generateKey(\n    src: string,\n    segmentId: number,\n    renditionId?: string,\n  ): string {\n    return `input:${src}:${segmentId}:${renditionId || \"default\"}`;\n  }\n\n  /**\n   * Get cached Input object\n   */\n  get(src: string, segmentId: number, renditionId?: string): Input | undefined {\n    const key = this.generateKey(src, segmentId, renditionId);\n    return this.cache.get(key);\n  }\n\n  /**\n   * Cache Input object\n   */\n  set(\n    src: string,\n    segmentId: number,\n    input: Input,\n    renditionId?: string,\n  ): void {\n    const key = this.generateKey(src, segmentId, renditionId);\n    this.cache.set(key, input);\n  }\n\n  /**\n   * Check if Input is cached\n   */\n  has(src: string, segmentId: number, renditionId?: string): boolean {\n    const key = this.generateKey(src, segmentId, renditionId);\n    return this.cache.has(key);\n  }\n\n  /**\n   * Clear all cached Input objects\n   */\n  clear(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get cache statistics for debugging\n   */\n  getStats() {\n    return {\n      size: this.cache.size,\n      cachedKeys: Array.from((this.cache as any).cache.keys()),\n    };\n  }\n}\n\n// Single global instance shared across all MediaEngine instances\nexport const globalInputCache = new GlobalInputCache();\n\n// Export for debugging (works in both browser and server)\n(\n  globalThis as typeof globalThis & { debugInputCache: typeof globalInputCache }\n).debugInputCache = globalInputCache;\n"],"mappings":";;;;;;;;AAQA,IAAM,mBAAN,MAAuB;;eACL,IAAI,SAAwB,GAAG;;;;;;CAM/C,AAAQ,YACN,KACA,WACA,aACQ;AACR,SAAO,SAAS,IAAI,GAAG,UAAU,GAAG,eAAe;;;;;CAMrD,IAAI,KAAa,WAAmB,aAAyC;EAC3E,MAAM,MAAM,KAAK,YAAY,KAAK,WAAW,YAAY;AACzD,SAAO,KAAK,MAAM,IAAI,IAAI;;;;;CAM5B,IACE,KACA,WACA,OACA,aACM;EACN,MAAM,MAAM,KAAK,YAAY,KAAK,WAAW,YAAY;AACzD,OAAK,MAAM,IAAI,KAAK,MAAM;;;;;CAM5B,IAAI,KAAa,WAAmB,aAA+B;EACjE,MAAM,MAAM,KAAK,YAAY,KAAK,WAAW,YAAY;AACzD,SAAO,KAAK,MAAM,IAAI,IAAI;;;;;CAM5B,QAAc;AACZ,OAAK,MAAM,OAAO;;;;;CAMpB,WAAW;AACT,SAAO;GACL,MAAM,KAAK,MAAM;GACjB,YAAY,MAAM,KAAM,KAAK,MAAc,MAAM,MAAM,CAAC;GACzD;;;AAKL,MAAa,mBAAmB,IAAI,kBAAkB;AAGtD,AACE,WACA,kBAAkB"}

package/dist/elements/EFMedia/shared/MediaTaskUtils.d.ts

@@ -1,23 +1,17 @@
-import { Task } from '@lit/task';
-import { AudioRendition, MediaEngine, VideoRendition } from '../../../transcoding/types';
-import { BufferedSeekingInput } from '../BufferedSeekingInput';
+import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
+import { AudioRendition, VideoRendition } from "../../../transcoding/types/index.js";
+import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/shared/MediaTaskUtils.d.ts
+
 /**
  * Generic rendition type that can be either audio or video
  */
-export type MediaRendition = AudioRendition | VideoRendition;
-/**
- * Generic task type for init segment fetch
- */
-export type InitSegmentFetchTask = Task<readonly [MediaEngine | undefined], ArrayBuffer>;
-/**
- * Generic task type for segment ID calculation
- */
-export type SegmentIdTask = Task<readonly [MediaEngine | undefined, number], number | undefined>;
-/**
- * Generic task type for segment fetch
- */
-export type SegmentFetchTask = Task<readonly [MediaEngine | undefined, number | undefined], ArrayBuffer>;
+type MediaRendition = AudioRendition | VideoRendition;
 /**
  * Generic task type for input creation
  */
-export type InputTask = Task<readonly [ArrayBuffer, ArrayBuffer], BufferedSeekingInput | undefined>;
+type InputTask = Task<readonly [ArrayBuffer, ArrayBuffer], BufferedSeekingInput | undefined>;
+//#endregion
+export { InputTask, MediaRendition };
+//# sourceMappingURL=MediaTaskUtils.d.ts.map

package/dist/elements/EFMedia/shared/PrecisionUtils.js

@@ -1,8 +1,33 @@
+//#region src/elements/EFMedia/shared/PrecisionUtils.ts
+/**
+* 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.
+*/
 const roundToMilliseconds = (timeMs) => {
 	return Math.round(timeMs * 1e3) / 1e3;
 };
+/**
+* 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.
+*/
 const convertToScaledTime = (timeMs, timescale) => {
 	const scaledTime = timeMs / 1e3 * timescale;
 	return Math.round(scaledTime);
 };
+
+//#endregion
 export { convertToScaledTime, roundToMilliseconds };
+//# sourceMappingURL=PrecisionUtils.js.map

package/dist/elements/EFMedia/shared/PrecisionUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrecisionUtils.js","names":[],"sources":["../../../../src/elements/EFMedia/shared/PrecisionUtils.ts"],"sourcesContent":["/**\n * Centralized precision utilities for consistent timing calculations across the media pipeline.\n *\n * The key insight is that floating-point precision errors can cause inconsistencies between:\n * 1. Segment selection logic (in AssetMediaEngine.computeSegmentId)\n * 2. Sample finding logic (in SampleBuffer.find)\n * 3. Timeline mapping (in BufferedSeekingInput.seek)\n *\n * All timing calculations must use the same rounding strategy to ensure consistency.\n */\n\n/**\n * Round time to millisecond precision to handle floating-point precision issues.\n * Uses Math.round for consistent behavior across the entire pipeline.\n *\n * This function should be used for ALL time-related calculations that need to be\n * compared between different parts of the system.\n */\nexport const roundToMilliseconds = (timeMs: number): number => {\n  // Round to 3 decimal places (microsecond precision)\n  return Math.round(timeMs * 1000) / 1000;\n};\n\n/**\n * Convert media time (in seconds) to scaled time units using consistent rounding.\n * This is used in segment selection to convert from milliseconds to timescale units.\n */\nexport const convertToScaledTime = (\n  timeMs: number,\n  timescale: number,\n): number => {\n  const scaledTime = (timeMs / 1000) * timescale;\n  return Math.round(scaledTime);\n};\n\n/**\n * Convert scaled time units back to media time (in milliseconds) using consistent rounding.\n * This is the inverse of convertToScaledTime.\n */\nexport const convertFromScaledTime = (\n  scaledTime: number,\n  timescale: number,\n): number => {\n  const timeMs = (scaledTime / timescale) * 1000;\n  return roundToMilliseconds(timeMs);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAkBA,MAAa,uBAAuB,WAA2B;AAE7D,QAAO,KAAK,MAAM,SAAS,IAAK,GAAG;;;;;;AAOrC,MAAa,uBACX,QACA,cACW;CACX,MAAM,aAAc,SAAS,MAAQ;AACrC,QAAO,KAAK,MAAM,WAAW"}

package/dist/elements/EFMedia/shared/ThumbnailExtractor.js

@@ -1,9 +1,18 @@
 import { globalInputCache } from "./GlobalInputCache.js";
 import { ALL_FORMATS, BlobSource, CanvasSink, Input } from "mediabunny";
+
+//#region src/elements/EFMedia/shared/ThumbnailExtractor.ts
+/**
+* Shared thumbnail extraction logic for all MediaEngine implementations
+* Eliminates code duplication and provides consistent behavior
+*/
 var ThumbnailExtractor = class {
 	constructor(mediaEngine) {
 		this.mediaEngine = mediaEngine;
 	}
+	/**
+	* Extract thumbnails at multiple timestamps efficiently using segment batching
+	*/
 	async extractThumbnails(timestamps, rendition, durationMs) {
 		if (timestamps.length === 0) return [];
 		const validTimestamps = timestamps.filter((timeMs) => timeMs >= 0 && timeMs <= durationMs);
@@ -25,6 +34,9 @@ var ThumbnailExtractor = class {
 			return results.get(t) || null;
 		});
 	}
+	/**
+	* Group timestamps by segment ID for efficient batch processing
+	*/
 	groupTimestampsBySegment(timestamps, rendition) {
 		const segmentGroups = /* @__PURE__ */ new Map();
 		for (const timeMs of timestamps) try {
@@ -40,6 +52,9 @@ var ThumbnailExtractor = class {
 		}
 		return segmentGroups;
 	}
+	/**
+	* Extract thumbnails for a specific segment using CanvasSink
+	*/
 	async extractSegmentThumbnails(segmentId, timestamps, rendition) {
 		const results = /* @__PURE__ */ new Map();
 		try {
@@ -82,8 +97,15 @@ var ThumbnailExtractor = class {
 		}
 		return results;
 	}
+	/**
+	* Convert global timestamps to segment-relative timestamps for mediabunny
+	* This is where the main difference between JIT and Asset engines lies
+	*/
 	convertToSegmentRelativeTimestamps(globalTimestamps, segmentId, rendition) {
 		return this.mediaEngine.convertToSegmentRelativeTimestamps(globalTimestamps, segmentId, rendition);
 	}
 };
+
+//#endregion
 export { ThumbnailExtractor };
+//# sourceMappingURL=ThumbnailExtractor.js.map

package/dist/elements/EFMedia/shared/ThumbnailExtractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThumbnailExtractor.js","names":["mediaEngine: BaseMediaEngine"],"sources":["../../../../src/elements/EFMedia/shared/ThumbnailExtractor.ts"],"sourcesContent":["import { ALL_FORMATS, BlobSource, CanvasSink, Input } from \"mediabunny\";\nimport type {\n  ThumbnailResult,\n  VideoRendition,\n} from \"../../../transcoding/types/index.js\";\nimport type { BaseMediaEngine } from \"../BaseMediaEngine.js\";\nimport { globalInputCache } from \"./GlobalInputCache.js\";\n\n/**\n * Shared thumbnail extraction logic for all MediaEngine implementations\n * Eliminates code duplication and provides consistent behavior\n */\nexport class ThumbnailExtractor {\n  constructor(private mediaEngine: BaseMediaEngine) {}\n\n  /**\n   * Extract thumbnails at multiple timestamps efficiently using segment batching\n   */\n  async extractThumbnails(\n    timestamps: number[],\n    rendition: VideoRendition,\n    durationMs: number,\n  ): Promise<(ThumbnailResult | null)[]> {\n    if (timestamps.length === 0) {\n      return [];\n    }\n\n    // Validate and filter timestamps within bounds\n    const validTimestamps = timestamps.filter(\n      (timeMs) => timeMs >= 0 && timeMs <= durationMs,\n    );\n\n    if (validTimestamps.length === 0) {\n      console.warn(\n        `ThumbnailExtractor: All timestamps out of bounds (0-${durationMs}ms)`,\n      );\n      return timestamps.map(() => null);\n    }\n\n    // Group timestamps by segment for batch processing\n    const segmentGroups = this.groupTimestampsBySegment(\n      validTimestamps,\n      rendition,\n    );\n\n    // Extract batched by segment using CanvasSink\n    const results = new Map<number, ThumbnailResult | null>();\n\n    for (const [segmentId, segmentTimestamps] of segmentGroups) {\n      try {\n        const segmentResults = await this.extractSegmentThumbnails(\n          segmentId,\n          segmentTimestamps,\n          rendition,\n        );\n\n        for (const [timestamp, thumbnail] of segmentResults) {\n          results.set(timestamp, thumbnail);\n        }\n      } catch (error) {\n        console.warn(\n          `ThumbnailExtractor: Failed to extract thumbnails for segment ${segmentId}:`,\n          error,\n        );\n        // Mark all timestamps in this segment as failed\n        for (const timestamp of segmentTimestamps) {\n          results.set(timestamp, null);\n        }\n      }\n    }\n\n    // Return in original order, null for any that failed or were out of bounds\n    return timestamps.map((t) => {\n      // If timestamp was out of bounds, return null\n      if (t < 0 || t > durationMs) {\n        return null;\n      }\n      return results.get(t) || null;\n    });\n  }\n\n  /**\n   * Group timestamps by segment ID for efficient batch processing\n   */\n  private groupTimestampsBySegment(\n    timestamps: number[],\n    rendition: VideoRendition,\n  ): Map<number, number[]> {\n    const segmentGroups = new Map<number, number[]>();\n\n    for (const timeMs of timestamps) {\n      try {\n        const segmentId = this.mediaEngine.computeSegmentId(timeMs, rendition);\n        if (segmentId !== undefined) {\n          if (!segmentGroups.has(segmentId)) {\n            segmentGroups.set(segmentId, []);\n          }\n          const segmentGroup = segmentGroups.get(segmentId) ?? [];\n          if (!segmentGroup) {\n            segmentGroups.set(segmentId, []);\n          }\n          segmentGroup.push(timeMs);\n        }\n      } catch (error) {\n        console.warn(\n          `ThumbnailExtractor: Could not compute segment for timestamp ${timeMs}:`,\n          error,\n        );\n      }\n    }\n\n    return segmentGroups;\n  }\n\n  /**\n   * Extract thumbnails for a specific segment using CanvasSink\n   */\n  private async extractSegmentThumbnails(\n    segmentId: number,\n    timestamps: number[],\n    rendition: VideoRendition,\n  ): Promise<Map<number, ThumbnailResult | null>> {\n    const results = new Map<number, ThumbnailResult | null>();\n\n    try {\n      // Get segment data through existing media engine methods (uses caches)\n      const abortController = new AbortController();\n      const [initSegment, mediaSegment] = await Promise.all([\n        this.mediaEngine.fetchInitSegment(rendition, abortController.signal),\n        this.mediaEngine.fetchMediaSegment(segmentId, rendition),\n      ]);\n\n      // Create Input for this segment using global shared cache\n      const segmentBlob = new Blob([initSegment, mediaSegment]);\n\n      let input = globalInputCache.get(rendition.src, segmentId, rendition.id);\n      if (!input) {\n        input = new Input({\n          formats: ALL_FORMATS,\n          source: new BlobSource(segmentBlob),\n        });\n        globalInputCache.set(rendition.src, segmentId, input, rendition.id);\n      }\n\n      // Set up CanvasSink for batched extraction\n      const videoTrack = await input.getPrimaryVideoTrack();\n      if (!videoTrack) {\n        // No video track - return nulls for all timestamps\n        for (const timestamp of timestamps) {\n          results.set(timestamp, null);\n        }\n        return results;\n      }\n\n      const sink = new CanvasSink(videoTrack);\n\n      // Convert global timestamps to segment-relative (in seconds for mediabunny)\n      const relativeTimestamps = this.convertToSegmentRelativeTimestamps(\n        timestamps,\n        segmentId,\n        rendition,\n      );\n\n      // Batch extract all thumbnails for this segment\n      const timestampResults = [];\n      for await (const result of sink.canvasesAtTimestamps(\n        relativeTimestamps,\n      )) {\n        timestampResults.push(result);\n      }\n\n      // Map results back to original timestamps\n      for (let i = 0; i < timestamps.length; i++) {\n        const globalTimestamp = timestamps[i];\n        if (globalTimestamp === undefined) {\n          continue;\n        }\n\n        const result = timestampResults[i];\n\n        if (result?.canvas) {\n          const canvas = result.canvas;\n          if (\n            canvas instanceof HTMLCanvasElement ||\n            canvas instanceof OffscreenCanvas\n          ) {\n            results.set(globalTimestamp, {\n              timestamp: globalTimestamp,\n              thumbnail: canvas,\n            });\n          } else {\n            results.set(globalTimestamp, null);\n          }\n        } else {\n          results.set(globalTimestamp, null);\n        }\n      }\n    } catch (error) {\n      console.error(\n        `ThumbnailExtractor: Failed to extract thumbnails for segment ${segmentId}:`,\n        error,\n      );\n      // Return nulls for all timestamps on error\n      for (const timestamp of timestamps) {\n        results.set(timestamp, null);\n      }\n    }\n\n    return results;\n  }\n\n  /**\n   * Convert global timestamps to segment-relative timestamps for mediabunny\n   * This is where the main difference between JIT and Asset engines lies\n   */\n  private convertToSegmentRelativeTimestamps(\n    globalTimestamps: number[],\n    segmentId: number,\n    rendition: VideoRendition,\n  ): number[] {\n    return this.mediaEngine.convertToSegmentRelativeTimestamps(\n      globalTimestamps,\n      segmentId,\n      rendition,\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.js

@@ -3,12 +3,18 @@ import { AssetMediaEngine } from "../AssetMediaEngine.js";
 import { AssetIdMediaEngine } from "../AssetIdMediaEngine.js";
 import { JitMediaEngine } from "../JitMediaEngine.js";
 import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/tasks/makeMediaEngineTask.ts
 const getLatestMediaEngine = async (host, signal) => {
 	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.
+*/
 const createMediaEngine = (host) => {
 	const { src, assetId, urlGenerator, apiHost } = host;
 	if (assetId !== null && assetId !== void 0 && assetId.trim() !== "") {
@@ -25,6 +31,10 @@ const createMediaEngine = (host) => {
 	const url = urlGenerator.generateManifestUrl(src);
 	return JitMediaEngine.fetch(host, urlGenerator, url);
 };
+/**
+* Handle completion of media engine task - triggers necessary updates.
+* Extracted for testability.
+*/
 const handleMediaEngineComplete = (host) => {
 	host.requestUpdate("intrinsicDurationMs");
 	host.requestUpdate("ownCurrentTimeMs");
@@ -43,4 +53,7 @@ const makeMediaEngineTask = (host) => {
 		}
 	});
 };
+
+//#endregion
 export { getLatestMediaEngine, makeMediaEngineTask };
+//# sourceMappingURL=makeMediaEngineTask.js.map

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeMediaEngineTask.js","names":[],"sources":["../../../../src/elements/EFMedia/tasks/makeMediaEngineTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\nimport { EF_INTERACTIVE } from \"../../../EF_INTERACTIVE\";\nimport type { MediaEngine } from \"../../../transcoding/types\";\nimport type { EFMedia } from \"../../EFMedia\";\nimport { AssetIdMediaEngine } from \"../AssetIdMediaEngine\";\nimport { AssetMediaEngine } from \"../AssetMediaEngine\";\nimport { JitMediaEngine } from \"../JitMediaEngine\";\n\nexport const getLatestMediaEngine = async (\n  host: EFMedia,\n  signal: AbortSignal,\n): Promise<MediaEngine> => {\n  const mediaEngine = await host.mediaEngineTask.taskComplete;\n  signal.throwIfAborted();\n  if (!mediaEngine) {\n    throw new Error(\"Media engine is not available\");\n  }\n  return mediaEngine;\n};\n\n/**\n * Core logic for creating a MediaEngine with explicit dependencies.\n * Pure function that requires all dependencies to be provided.\n */\nexport const createMediaEngine = (host: EFMedia): Promise<MediaEngine> => {\n  const { src, assetId, urlGenerator, apiHost } = host;\n\n  // Check for AssetID mode first\n  if (assetId !== null && assetId !== undefined && assetId.trim() !== \"\") {\n    if (!apiHost) {\n      return Promise.reject(new Error(\"API host is required for AssetID mode\"));\n    }\n    return AssetIdMediaEngine.fetchByAssetId(\n      host,\n      urlGenerator,\n      assetId,\n      apiHost,\n    );\n  }\n\n  // Check for null/undefined/empty/whitespace src\n  if (!src || typeof src !== \"string\" || src.trim() === \"\") {\n    console.error(`Unsupported media source: ${src}, assetId: ${assetId}`);\n    return Promise.reject(new Error(\"Unsupported media source\"));\n  }\n\n  const lowerSrc = src.toLowerCase();\n  if (!lowerSrc.startsWith(\"http://\") && !lowerSrc.startsWith(\"https://\")) {\n    return AssetMediaEngine.fetch(host, urlGenerator, src);\n  }\n\n  // Remote (http/https) source, now check configuration\n  const configuration = host.closest(\"ef-configuration\");\n  if (configuration?.mediaEngine === \"local\") {\n    // Only use AssetMediaEngine for remote URLs when explicitly configured\n    return AssetMediaEngine.fetch(host, urlGenerator, src);\n  }\n\n  // Default: Use JitMediaEngine for remote URLs (transcoding service)\n  const url = urlGenerator.generateManifestUrl(src);\n  return JitMediaEngine.fetch(host, urlGenerator, url);\n};\n\n/**\n * Handle completion of media engine task - triggers necessary updates.\n * Extracted for testability.\n */\nexport const handleMediaEngineComplete = (host: EFMedia): void => {\n  host.requestUpdate(\"intrinsicDurationMs\");\n  host.requestUpdate(\"ownCurrentTimeMs\");\n  host.rootTimegroup?.requestUpdate(\"ownCurrentTimeMs\");\n  host.rootTimegroup?.requestUpdate(\"durationMs\");\n};\n\ntype MediaEngineTask = Task<readonly [string, string | null], MediaEngine>;\n\nexport const makeMediaEngineTask = (host: EFMedia): MediaEngineTask => {\n  return new Task(host, {\n    autoRun: EF_INTERACTIVE,\n    args: () => [host.src, host.assetId] as const,\n    task: async () => {\n      return createMediaEngine(host);\n    },\n    onComplete: (_value) => {\n      handleMediaEngineComplete(host);\n    },\n  });\n};\n"],"mappings":";;;;;;;AAQA,MAAa,uBAAuB,OAClC,MACA,WACyB;CACzB,MAAM,cAAc,MAAM,KAAK,gBAAgB;AAC/C,QAAO,gBAAgB;AACvB,KAAI,CAAC,YACH,OAAM,IAAI,MAAM,gCAAgC;AAElD,QAAO;;;;;;AAOT,MAAa,qBAAqB,SAAwC;CACxE,MAAM,EAAE,KAAK,SAAS,cAAc,YAAY;AAGhD,KAAI,YAAY,QAAQ,YAAY,UAAa,QAAQ,MAAM,KAAK,IAAI;AACtE,MAAI,CAAC,QACH,QAAO,QAAQ,uBAAO,IAAI,MAAM,wCAAwC,CAAC;AAE3E,SAAO,mBAAmB,eACxB,MACA,cACA,SACA,QACD;;AAIH,KAAI,CAAC,OAAO,OAAO,QAAQ,YAAY,IAAI,MAAM,KAAK,IAAI;AACxD,UAAQ,MAAM,6BAA6B,IAAI,aAAa,UAAU;AACtE,SAAO,QAAQ,uBAAO,IAAI,MAAM,2BAA2B,CAAC;;CAG9D,MAAM,WAAW,IAAI,aAAa;AAClC,KAAI,CAAC,SAAS,WAAW,UAAU,IAAI,CAAC,SAAS,WAAW,WAAW,CACrE,QAAO,iBAAiB,MAAM,MAAM,cAAc,IAAI;AAKxD,KADsB,KAAK,QAAQ,mBAAmB,EACnC,gBAAgB,QAEjC,QAAO,iBAAiB,MAAM,MAAM,cAAc,IAAI;CAIxD,MAAM,MAAM,aAAa,oBAAoB,IAAI;AACjD,QAAO,eAAe,MAAM,MAAM,cAAc,IAAI;;;;;;AAOtD,MAAa,6BAA6B,SAAwB;AAChE,MAAK,cAAc,sBAAsB;AACzC,MAAK,cAAc,mBAAmB;AACtC,MAAK,eAAe,cAAc,mBAAmB;AACrD,MAAK,eAAe,cAAc,aAAa;;AAKjD,MAAa,uBAAuB,SAAmC;AACrE,QAAO,IAAI,KAAK,MAAM;EACpB,SAAS;EACT,YAAY,CAAC,KAAK,KAAK,KAAK,QAAQ;EACpC,MAAM,YAAY;AAChB,UAAO,kBAAkB,KAAK;;EAEhC,aAAa,WAAW;AACtB,6BAA0B,KAAK;;EAElC,CAAC"}

package/dist/elements/EFMedia/videoTasks/MainVideoInputCache.js

@@ -1,11 +1,23 @@
+//#region src/elements/EFMedia/videoTasks/MainVideoInputCache.ts
+/**
+* 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)
+*/
 var MainVideoInputCache = class {
 	constructor() {
 		this.cache = /* @__PURE__ */ new Map();
 		this.maxCacheSize = 10;
 	}
+	/**
+	* Create a cache key that uniquely identifies a segment
+	*/
 	getCacheKey(src, segmentId, renditionId) {
 		return `${src}:${renditionId || "default"}:${segmentId}`;
 	}
+	/**
+	* Get or create BufferedSeekingInput for a main video segment
+	*/
 	async getOrCreateInput(src, segmentId, renditionId, createInputFn) {
 		const cacheKey = this.getCacheKey(src, segmentId, renditionId);
 		const cached = this.cache.get(cacheKey);
@@ -19,9 +31,15 @@ var MainVideoInputCache = class {
 		}
 		return input;
 	}
+	/**
+	* Clear the entire cache (called when video changes)
+	*/
 	clear() {
 		this.cache.clear();
 	}
+	/**
+	* Get cache statistics
+	*/
 	getStats() {
 		return {
 			size: this.cache.size,
@@ -29,4 +47,7 @@ var MainVideoInputCache = class {
 		};
 	}
 };
+
+//#endregion
 export { MainVideoInputCache };
+//# sourceMappingURL=MainVideoInputCache.js.map

package/dist/elements/EFMedia/videoTasks/MainVideoInputCache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MainVideoInputCache.js","names":[],"sources":["../../../../src/elements/EFMedia/videoTasks/MainVideoInputCache.ts"],"sourcesContent":["import type { BufferedSeekingInput } from \"../BufferedSeekingInput\";\n\n/**\n * Cache for main video BufferedSeekingInput instances\n * Main video segments are typically 2s long, so we can reuse the same input\n * for multiple frames within that segment (e.g., 60 frames at 30fps)\n */\nexport class MainVideoInputCache {\n  private cache = new Map<string, BufferedSeekingInput>();\n  private maxCacheSize = 10; // Keep last 10 main inputs (covers 20 seconds at 2s/segment)\n\n  /**\n   * Create a cache key that uniquely identifies a segment\n   */\n  private getCacheKey(\n    src: string,\n    segmentId: number,\n    renditionId: string | undefined,\n  ): string {\n    return `${src}:${renditionId || \"default\"}:${segmentId}`;\n  }\n\n  /**\n   * Get or create BufferedSeekingInput for a main video segment\n   */\n  async getOrCreateInput(\n    src: string,\n    segmentId: number,\n    renditionId: string | undefined,\n    createInputFn: () => Promise<BufferedSeekingInput | undefined>,\n  ): Promise<BufferedSeekingInput | undefined> {\n    const cacheKey = this.getCacheKey(src, segmentId, renditionId);\n\n    // Check if we already have this segment cached\n    const cached = this.cache.get(cacheKey);\n    if (cached) {\n      return cached;\n    }\n\n    // Create new input\n    const input = await createInputFn();\n    if (!input) {\n      return undefined;\n    }\n\n    // Add to cache and maintain size limit\n    this.cache.set(cacheKey, input);\n\n    // Evict oldest entries if cache is too large (LRU-like behavior)\n    if (this.cache.size > this.maxCacheSize) {\n      const oldestKey = this.cache.keys().next().value;\n      if (oldestKey !== undefined) {\n        this.cache.delete(oldestKey);\n      }\n    }\n\n    return input;\n  }\n\n  /**\n   * Clear the entire cache (called when video changes)\n   */\n  clear() {\n    this.cache.clear();\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getStats() {\n    return {\n      size: this.cache.size,\n      cacheKeys: Array.from(this.cache.keys()),\n    };\n  }\n}\n"],"mappings":";;;;;;AAOA,IAAa,sBAAb,MAAiC;;+BACf,IAAI,KAAmC;sBAChC;;;;;CAKvB,AAAQ,YACN,KACA,WACA,aACQ;AACR,SAAO,GAAG,IAAI,GAAG,eAAe,UAAU,GAAG;;;;;CAM/C,MAAM,iBACJ,KACA,WACA,aACA,eAC2C;EAC3C,MAAM,WAAW,KAAK,YAAY,KAAK,WAAW,YAAY;EAG9D,MAAM,SAAS,KAAK,MAAM,IAAI,SAAS;AACvC,MAAI,OACF,QAAO;EAIT,MAAM,QAAQ,MAAM,eAAe;AACnC,MAAI,CAAC,MACH;AAIF,OAAK,MAAM,IAAI,UAAU,MAAM;AAG/B,MAAI,KAAK,MAAM,OAAO,KAAK,cAAc;GACvC,MAAM,YAAY,KAAK,MAAM,MAAM,CAAC,MAAM,CAAC;AAC3C,OAAI,cAAc,OAChB,MAAK,MAAM,OAAO,UAAU;;AAIhC,SAAO;;;;;CAMT,QAAQ;AACN,OAAK,MAAM,OAAO;;;;;CAMpB,WAAW;AACT,SAAO;GACL,MAAM,KAAK,MAAM;GACjB,WAAW,MAAM,KAAK,KAAK,MAAM,MAAM,CAAC;GACzC"}

package/dist/elements/EFMedia/videoTasks/ScrubInputCache.js

@@ -1,8 +1,17 @@
+//#region src/elements/EFMedia/videoTasks/ScrubInputCache.ts
+/**
+* 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
+*/
 var ScrubInputCache = class {
 	constructor() {
 		this.cache = /* @__PURE__ */ new Map();
 		this.maxCacheSize = 5;
 	}
+	/**
+	* Get or create BufferedSeekingInput for a scrub segment
+	*/
 	async getOrCreateInput(segmentId, createInputFn) {
 		const cached = this.cache.get(segmentId);
 		if (cached) return cached;
@@ -15,9 +24,15 @@ var ScrubInputCache = class {
 		}
 		return input;
 	}
+	/**
+	* Clear the entire cache (called when video changes)
+	*/
 	clear() {
 		this.cache.clear();
 	}
+	/**
+	* Get cache statistics
+	*/
 	getStats() {
 		return {
 			size: this.cache.size,
@@ -25,4 +40,7 @@ var ScrubInputCache = class {
 		};
 	}
 };
+
+//#endregion
 export { ScrubInputCache };
+//# sourceMappingURL=ScrubInputCache.js.map