@remotion/media 4.0.506 → 4.0.508

package/dist/esm/index.mjs

@@ -40,7 +40,7 @@ var __callDispose = (stack, error, hasError) => {
 import { useMemo as useMemo3, useState as useState3 } from "react";
 import {
   Freeze,
-  Internals as Internals17,
+  Internals as Internals18,
   Interactive,
   Sequence,
   useRemotionEnvironment as useRemotionEnvironment2,
@@ -78,7 +78,7 @@ var getLoopDisplay = ({
 // src/audio/audio-for-preview.tsx
 import { useContext as useContext2, useEffect, useMemo, useRef, useState } from "react";
 import {
-  Internals as Internals7,
+  Internals as Internals8,
   Audio as RemotionAudio,
   useBufferState,
   useCurrentFrame,
@@ -137,7 +137,7 @@ var calculateEndTime = ({
 };
 
 // src/media-player.ts
-import { Internals as Internals5 } from "remotion";
+import { Internals as Internals6 } from "remotion";
 
 // src/audio-iterator-manager.ts
 import {
@@ -868,6 +868,51 @@ var getDurationOrCompute = async (input) => {
 // src/get-shared-input.ts
 import { ALL_FORMATS, Input, UrlSource } from "mediabunny";
 
+// src/max-cache-size.ts
+import { cancelRender, Internals as Internals4 } from "remotion";
+var getUncachedMaxCacheSize = (logLevel) => {
+  if (typeof window !== "undefined" && window.remotion_mediaCacheSizeInBytes !== undefined && window.remotion_mediaCacheSizeInBytes !== null) {
+    if (window.remotion_mediaCacheSizeInBytes < 240 * 1024 * 1024) {
+      cancelRender(new Error(`The minimum value for the "mediaCacheSizeInBytes" prop is 240MB (${240 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
+    }
+    if (window.remotion_mediaCacheSizeInBytes > 20000 * 1024 * 1024) {
+      cancelRender(new Error(`The maximum value for the "mediaCacheSizeInBytes" prop is 20GB (${20000 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
+    }
+    Internals4.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set using "mediaCacheSizeInBytes": ${(window.remotion_mediaCacheSizeInBytes / 1024 / 1024).toFixed(1)} MB`);
+    return window.remotion_mediaCacheSizeInBytes;
+  }
+  if (typeof window !== "undefined" && window.remotion_initialMemoryAvailable !== undefined && window.remotion_initialMemoryAvailable !== null) {
+    const value = window.remotion_initialMemoryAvailable / 2;
+    if (value < 500 * 1024 * 1024) {
+      Internals4.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on minimum value of 500MB (which is more than half of the available system memory!)`);
+      return 500 * 1024 * 1024;
+    }
+    if (value > 20000 * 1024 * 1024) {
+      Internals4.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on maximum value of 20GB (which is less than half of the available system memory)`);
+      return 20000 * 1024 * 1024;
+    }
+    Internals4.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on available memory (50% of available memory): ${(value / 1024 / 1024).toFixed(1)} MB`);
+    return value;
+  }
+  return 1000 * 1000 * 1000;
+};
+var cachedMaxCacheSize = null;
+var getMaxVideoCacheSize = (logLevel) => {
+  if (cachedMaxCacheSize !== null) {
+    return cachedMaxCacheSize;
+  }
+  cachedMaxCacheSize = getUncachedMaxCacheSize(logLevel);
+  return cachedMaxCacheSize;
+};
+var MIN_SOURCE_CACHE_SIZE = 8 * 1024 * 1024;
+var MAX_SOURCE_CACHE_SIZE = 64 * 1024 * 1024;
+var getMaxSourceCacheSizeFromBudget = (budget) => {
+  return Math.min(MAX_SOURCE_CACHE_SIZE, Math.max(MIN_SOURCE_CACHE_SIZE, Math.floor(budget / 16)));
+};
+var getMaxSourceCacheSize = (logLevel) => {
+  return getMaxSourceCacheSizeFromBudget(getMaxVideoCacheSize(logLevel));
+};
+
 // src/request-init.ts
 var normalizeMediaHeaders = (headers) => {
   if (!headers) {
@@ -950,7 +995,8 @@ var getSharedInputCacheKey = ({
 var acquireSharedInput = ({
   src,
   credentials,
-  requestInit
+  requestInit,
+  logLevel
 }) => {
   const normalizedRequestInit = normalizeMediaRequestInit(requestInit);
   const cacheKey = getSharedInputCacheKey({
@@ -968,7 +1014,10 @@ var acquireSharedInput = ({
     requestInit: normalizedRequestInit
   });
   const input = new Input({
-    source: new UrlSource(src, resolvedRequestInit ? { requestInit: resolvedRequestInit } : undefined),
+    source: new UrlSource(src, {
+      maxCacheSize: getMaxSourceCacheSize(logLevel),
+      ...resolvedRequestInit ? { requestInit: resolvedRequestInit } : undefined
+    }),
     formats: ALL_FORMATS
   });
   sharedInputs[cacheKey] = { input, refCount: 1 };
@@ -1107,7 +1156,7 @@ class PremountAwareDelayPlayback {
 
 // src/video-iterator-manager.ts
 import { CanvasSink } from "mediabunny";
-import { Internals as Internals4 } from "remotion";
+import { Internals as Internals5 } from "remotion";
 
 // src/helpers/round-to-4-digits.ts
 var roundTo4Digits = (timestamp) => {
@@ -1517,7 +1566,7 @@ var createVideoIterator = async (timeToSeek, cache) => {
 };
 
 // src/video-iterator-manager.ts
-var { runEffectChain } = Internals4;
+var { runEffectChain } = Internals5;
 var isSequentialMediaTimeAdvance = ({
   previousTime,
   newTime,
@@ -1596,7 +1645,7 @@ var videoIteratorManager = async ({
     if (callback) {
       callback(frame.canvas);
     }
-    Internals4.Log.trace({ logLevel, tag: "@remotion/media" }, `[MediaPlayer] Drew frame ${frame.timestamp.toFixed(3)}s`);
+    Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, `[MediaPlayer] Drew frame ${frame.timestamp.toFixed(3)}s`);
   };
   const redrawCurrentFrame = async () => {
     if (!lastDrawnFrame) {
@@ -1608,7 +1657,7 @@ var videoIteratorManager = async ({
     if (callback) {
       callback(lastDrawnFrame.canvas);
     }
-    Internals4.Log.trace({ logLevel, tag: "@remotion/media" }, `[MediaPlayer] Redrew frame ${lastDrawnFrame.timestamp.toFixed(3)}s with updated effects`);
+    Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, `[MediaPlayer] Redrew frame ${lastDrawnFrame.timestamp.toFixed(3)}s with updated effects`);
   };
   const startVideoIterator = async (timeToSeek, nonce) => {
     let __stack = [];
@@ -1786,7 +1835,8 @@ class MediaPlayer {
     const { input, cacheKey } = acquireSharedInput({
       src: this.src,
       credentials,
-      requestInit
+      requestInit,
+      logLevel
     });
     this.input = input;
     this.inputCacheKey = cacheKey;
@@ -1858,7 +1908,7 @@ class MediaPlayer {
           if (isNetworkError(err)) {
             throw error;
           }
-          Internals5.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Failed to recognize format for ${this.src}`, error);
+          Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Failed to recognize format for ${this.src}`, error);
           return { type: "unknown-container-format" };
         }
         const [durationInSeconds, videoTrack, audioTracks] = await Promise.all([
@@ -1968,16 +2018,16 @@ class MediaPlayer {
           if (this.isDisposalError()) {
             return { type: "disposed" };
           }
-          Internals5.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to start audio and video iterators", error);
+          Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to start audio and video iterators", error);
         }
         return { type: "success", durationInSeconds };
       } catch (error) {
         const err = error;
         if (isNetworkError(err)) {
-          Internals5.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Network/CORS error for ${this.src}`, err);
+          Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Network/CORS error for ${this.src}`, err);
           return { type: "network-error" };
         }
-        Internals5.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to initialize", error);
+        Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to initialize", error);
         throw error;
       }
     } catch (_catch) {
@@ -2273,7 +2323,7 @@ var callOnErrorAndResolve = ({
 
 // src/use-common-effects.ts
 import { useContext, useLayoutEffect } from "react";
-import { Internals as Internals6 } from "remotion";
+import { Internals as Internals7 } from "remotion";
 var useCommonEffects = ({
   mediaPlayerRef,
   mediaPlayerReady,
@@ -2297,7 +2347,7 @@ var useCommonEffects = ({
   logLevel,
   label
 }) => {
-  const sharedAudioContext = useContext(Internals6.SharedAudioContext);
+  const sharedAudioContext = useContext(Internals7.SharedAudioContext);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer)
@@ -2415,7 +2465,7 @@ var useCommonEffects = ({
     if (!mediaPlayer || !mediaPlayerReady)
       return;
     mediaPlayer.seekTo(currentTime).catch(() => {});
-    Internals6.Log.trace({ logLevel, tag: "@remotion/media" }, `[${label}] Updating target time to ${currentTime.toFixed(3)}s`);
+    Internals7.Log.trace({ logLevel, tag: "@remotion/media" }, `[${label}] Updating target time to ${currentTime.toFixed(3)}s`);
   }, [currentTime, logLevel, mediaPlayerReady, label, mediaPlayerRef]);
 };
 
@@ -2432,7 +2482,7 @@ var {
   warnAboutTooHighVolume,
   usePreload,
   SequenceContext
-} = Internals7;
+} = Internals8;
 var AudioForPreviewAssertedShowing = ({
   src,
   playbackRate,
@@ -2465,7 +2515,7 @@ var AudioForPreviewAssertedShowing = ({
   const [mediaPlayerReady, setMediaPlayerReady] = useState(false);
   const [shouldFallbackToNativeAudio, setShouldFallbackToNativeAudio] = useState(false);
   const [playing] = Timeline.usePlayingState();
-  const { playbackRate: globalPlaybackRate } = Internals7.usePlaybackRate();
+  const { playbackRate: globalPlaybackRate } = Internals8.usePlaybackRate();
   const sharedAudioContext = useContext2(SharedAudioContext);
   const buffer = useBufferState();
   const [playerMuted] = usePlayerMutedState();
@@ -2491,12 +2541,12 @@ var AudioForPreviewAssertedShowing = ({
   const isPremounting = Boolean(parentSequence?.premounting);
   const isPostmounting = Boolean(parentSequence?.postmounting);
   const sequenceOffset = (parentSequence?.absoluteFrom ?? 0) / videoConfig.fps;
-  const bufferingContext = useContext2(Internals7.BufferingContextReact);
+  const bufferingContext = useContext2(Internals8.BufferingContextReact);
   if (!bufferingContext) {
     throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
   }
   const effectiveMuted = muted || playerMuted || userPreferredVolume <= 0;
-  const isPlayerBuffering = Internals7.useIsPlayerBuffering(bufferingContext);
+  const isPlayerBuffering = Internals8.useIsPlayerBuffering(bufferingContext);
   const initialPlaying = useRef(playing && !isPlayerBuffering);
   const initialIsPremounting = useRef(isPremounting);
   const initialIsPostmounting = useRef(isPostmounting);
@@ -2592,7 +2642,7 @@ var AudioForPreviewAssertedShowing = ({
           if (action === "fail") {
             throw errorToUse;
           } else {
-            Internals7.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+            Internals8.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
             setShouldFallbackToNativeAudio(true);
           }
         };
@@ -2618,7 +2668,7 @@ var AudioForPreviewAssertedShowing = ({
         if (result.type === "success") {
           setMediaPlayerReady(true);
           setMediaDurationInSeconds(result.durationInSeconds);
-          Internals7.Log.trace({ logLevel, tag: "@remotion/media" }, `[AudioForPreview] MediaPlayer initialized successfully`);
+          Internals8.Log.trace({ logLevel, tag: "@remotion/media" }, `[AudioForPreview] MediaPlayer initialized successfully`);
         }
       }).catch((error) => {
         const [action, errorToUse] = callOnErrorAndResolve({
@@ -2631,7 +2681,7 @@ var AudioForPreviewAssertedShowing = ({
         if (action === "fail") {
           throw errorToUse;
         } else {
-          Internals7.Log.error({ logLevel, tag: "@remotion/media" }, "[AudioForPreview] Failed to initialize MediaPlayer", error);
+          Internals8.Log.error({ logLevel, tag: "@remotion/media" }, "[AudioForPreview] Failed to initialize MediaPlayer", error);
           setShouldFallbackToNativeAudio(true);
         }
       });
@@ -2646,12 +2696,12 @@ var AudioForPreviewAssertedShowing = ({
       if (action === "fail") {
         throw errorToUse;
       }
-      Internals7.Log.error({ logLevel, tag: "@remotion/media" }, "[AudioForPreview] MediaPlayer initialization failed", errorToUse);
+      Internals8.Log.error({ logLevel, tag: "@remotion/media" }, "[AudioForPreview] MediaPlayer initialization failed", errorToUse);
       setShouldFallbackToNativeAudio(true);
     }
     return () => {
       if (mediaPlayerRef.current) {
-        Internals7.Log.trace({ logLevel, tag: "@remotion/media" }, `[AudioForPreview] Disposing MediaPlayer`);
+        Internals8.Log.trace({ logLevel, tag: "@remotion/media" }, `[AudioForPreview] Disposing MediaPlayer`);
         mediaPlayerRef.current.dispose();
         mediaPlayerRef.current = null;
       }
@@ -2719,7 +2769,7 @@ var AudioForPreview = ({
   style
 }) => {
   const preloadedSrc = usePreload(src);
-  const defaultLogLevel = Internals7.useLogLevel();
+  const defaultLogLevel = Internals8.useLogLevel();
   const frame = useCurrentFrame();
   const videoConfig = useVideoConfig();
   const currentTime = frame / videoConfig.fps;
@@ -2780,7 +2830,7 @@ import { useContext as useContext3, useLayoutEffect as useLayoutEffect2, useMemo
 import {
   cancelRender as cancelRender2,
   Html5Audio,
-  Internals as Internals16,
+  Internals as Internals17,
   random,
   useCurrentFrame as useCurrentFrame2,
   useDelayRender,
@@ -2789,15 +2839,28 @@ import {
 
 // src/caches.ts
 import React2 from "react";
-import { cancelRender, Internals as Internals12 } from "remotion";
+import { Internals as Internals15 } from "remotion";
 
 // src/audio-extraction/audio-manager.ts
-import { Internals as Internals9 } from "remotion";
+import { Internals as Internals10 } from "remotion";
 
 // src/audio-extraction/audio-iterator.ts
-import { Internals as Internals8 } from "remotion";
+import { Internals as Internals9 } from "remotion";
 
 // src/audio-extraction/audio-cache.ts
+var BYTES_PER_SAMPLE = {
+  u8: 1,
+  s16: 2,
+  s32: 4,
+  f32: 4,
+  "u8-planar": 1,
+  "s16-planar": 2,
+  "s32-planar": 4,
+  "f32-planar": 4
+};
+var getAudioSampleByteSize = (sample) => {
+  return sample.numberOfFrames * sample.numberOfChannels * BYTES_PER_SAMPLE[sample.format];
+};
 var makeAudioCache = () => {
   const timestamps = [];
   const samples = {};
@@ -2844,6 +2907,13 @@ var makeAudioCache = () => {
   const getOpenTimestamps = () => {
     return timestamps;
   };
+  const getTotalSize = () => {
+    let total = 0;
+    for (const timestamp of timestamps) {
+      total += getAudioSampleByteSize(samples[timestamp]);
+    }
+    return total;
+  };
   const getOldestTimestamp = () => {
     return timestamps[0];
   };
@@ -2861,7 +2931,8 @@ var makeAudioCache = () => {
     getSamples,
     getOldestTimestamp,
     getNewestTimestamp,
-    getOpenTimestamps
+    getOpenTimestamps,
+    getTotalSize
   };
 };
 
@@ -2874,7 +2945,7 @@ var warnAboutMatroskaOnce = (src, logLevel) => {
     return;
   }
   warned[src] = true;
-  Internals8.Log.warn({ logLevel, tag: "@remotion/media" }, `Audio from ${src} will need to be read from the beginning. https://www.remotion.dev/docs/media/support#matroska-limitation`);
+  Internals9.Log.warn({ logLevel, tag: "@remotion/media" }, `Audio from ${src} will need to be read from the beginning. https://www.remotion.dev/docs/media/support#matroska-limitation`);
 };
 var makeAudioIterator2 = ({
   audioSampleSink,
@@ -2942,13 +3013,13 @@ var makeAudioIterator2 = ({
     if (openTimestamps.length > 0) {
       const first = openTimestamps[0];
       const last = openTimestamps[openTimestamps.length - 1];
-      Internals8.Log.verbose({ logLevel, tag: "@remotion/media" }, "Open audio samples for src", src, `${first.toFixed(3)}...${last.toFixed(3)}`);
+      Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, "Open audio samples for src", src, `${first.toFixed(3)}...${last.toFixed(3)}`);
     }
   };
   const getCacheStats = () => {
     return {
       count: cache.getOpenTimestamps().length,
-      size: cache.getOpenTimestamps().reduce((acc, t) => acc + t, 0)
+      size: cache.getTotalSize()
     };
   };
   const canSatisfyRequestedTime = (timestamp) => {
@@ -2991,8 +3062,11 @@ var makeAudioIterator2 = ({
 };
 
 // src/audio-extraction/audio-manager.ts
-var makeAudioManager = () => {
+var makeAudioManager = ({
+  getTotalCacheStats
+}) => {
   const iterators = [];
+  let disposed = false;
   const makeIterator = ({
     timeInSeconds,
     src,
@@ -3039,7 +3113,7 @@ var makeAudioManager = () => {
       if (seenKeys.has(key)) {
         iterator.prepareForDeletion();
         iterators.splice(iterators.indexOf(iterator), 1);
-        Internals9.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted duplicate iterator for ${iterator.src}`);
+        Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted duplicate iterator for ${iterator.src}`);
       }
       seenKeys.add(key);
     }
@@ -3053,6 +3127,9 @@ var makeAudioManager = () => {
     logLevel,
     maxCacheSize
   }) => {
+    if (disposed) {
+      throw new Error("Media cache has already been disposed");
+    }
     let attempts = 0;
     const maxAttempts = 3;
     while ((await getTotalCacheStats()).totalSize > maxCacheSize && attempts < maxAttempts) {
@@ -3060,7 +3137,7 @@ var makeAudioManager = () => {
       attempts++;
     }
     if ((await getTotalCacheStats()).totalSize > maxCacheSize && attempts >= maxAttempts) {
-      Internals9.Log.warn({ logLevel, tag: "@remotion/media" }, `Audio cache: Exceeded max cache size after ${maxAttempts} attempts. Still ${(await getTotalCacheStats()).totalSize} bytes used, target was ${maxCacheSize} bytes.`);
+      Internals10.Log.warn({ logLevel, tag: "@remotion/media" }, `Audio cache: Exceeded max cache size after ${maxAttempts} attempts. Still ${(await getTotalCacheStats()).totalSize} bytes used, target was ${maxCacheSize} bytes.`);
     }
     for (const iterator of iterators) {
       if (iterator.src === src && await iterator.waitForCompletion() && iterator.canSatisfyRequestedTime(timeInSeconds)) {
@@ -3075,6 +3152,9 @@ var makeAudioManager = () => {
       }
     }
     deleteDuplicateIterators(logLevel);
+    if (disposed) {
+      throw new Error("Media cache has already been disposed");
+    }
     return makeIterator({
       src,
       timeInSeconds,
@@ -3099,6 +3179,19 @@ var makeAudioManager = () => {
       iterator.logOpenFrames();
     }
   };
+  const clearAll = () => {
+    for (const iterator of iterators) {
+      iterator.prepareForDeletion();
+    }
+    iterators.length = 0;
+  };
+  const dispose = () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    clearAll();
+  };
   let queue = Promise.resolve(undefined);
   return {
     getIterator: ({
@@ -3124,13 +3217,252 @@ var makeAudioManager = () => {
     getCacheStats,
     getIteratorMostInThePast,
     logOpenFrames,
-    deleteDuplicateIterators
+    deleteDuplicateIterators,
+    clearAll,
+    dispose
   };
 };
 
-// src/video-extraction/keyframe-manager.ts
+// src/get-sink.ts
+import { Internals as Internals12 } from "remotion";
+
+// src/video-extraction/get-frames-since-keyframe.ts
+import {
+  ALL_FORMATS as ALL_FORMATS2,
+  AudioSampleSink,
+  EncodedPacketSink,
+  Input as Input2,
+  MATROSKA,
+  UrlSource as UrlSource2,
+  VideoSampleSink,
+  WEBM
+} from "mediabunny";
 import { Internals as Internals11 } from "remotion";
 
+// src/browser-can-use-webgl2.ts
+var browserCanUseWebGl2 = null;
+var browserCanUseWebGl2Uncached = () => {
+  const canvas = new OffscreenCanvas(1, 1);
+  const context = canvas.getContext("webgl2");
+  return context !== null;
+};
+var canBrowserUseWebGl2 = () => {
+  if (browserCanUseWebGl2 !== null) {
+    return browserCanUseWebGl2;
+  }
+  browserCanUseWebGl2 = browserCanUseWebGl2Uncached();
+  return browserCanUseWebGl2;
+};
+
+// src/video-extraction/remember-actual-matroska-timestamps.ts
+var rememberActualMatroskaTimestamps = (isMatroska) => {
+  const observations = [];
+  const observeTimestamp = (startTime) => {
+    if (!isMatroska) {
+      return;
+    }
+    observations.push(startTime);
+  };
+  const getRealTimestamp = (observedTimestamp) => {
+    if (!isMatroska) {
+      return observedTimestamp;
+    }
+    return observations.find((observation) => Math.abs(observedTimestamp - observation) < 0.001) ?? null;
+  };
+  return {
+    observeTimestamp,
+    getRealTimestamp
+  };
+};
+
+// src/video-extraction/get-frames-since-keyframe.ts
+var getRetryDelay = () => {
+  return null;
+};
+var getFormatOrNullOrNetworkError = async (input) => {
+  try {
+    return await input.getFormat();
+  } catch (err) {
+    if (isNetworkError(err)) {
+      return "network-error";
+    }
+    return null;
+  }
+};
+var makeSinks = (src, logLevel, credentials, requestInit) => {
+  const resolvedRequestInit = resolveRequestInit({ credentials, requestInit });
+  const input = new Input2({
+    formats: ALL_FORMATS2,
+    source: new UrlSource2(src, {
+      getRetryDelay,
+      maxCacheSize: getMaxSourceCacheSize(logLevel),
+      ...resolvedRequestInit ? { requestInit: resolvedRequestInit } : undefined
+    })
+  });
+  const getSinks = async () => {
+    const format = await getFormatOrNullOrNetworkError(input);
+    const isMatroska = format === MATROSKA || format === WEBM;
+    const getVideoSinks = async () => {
+      if (format === "network-error") {
+        return "network-error";
+      }
+      if (format === null) {
+        return "unknown-container-format";
+      }
+      const videoTrack = await input.getPrimaryVideoTrack();
+      if (!videoTrack) {
+        return "no-video-track";
+      }
+      if (await videoTrack.isLive()) {
+        throw new Error("Live streams are not currently supported by Remotion. Sorry! Source: " + src);
+      }
+      if (await videoTrack.isRelativeToUnixEpoch()) {
+        throw new Error("Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: " + src);
+      }
+      const canDecode = await videoTrack.canDecode();
+      if (!canDecode) {
+        if (videoTrack.codec === "prores") {
+          return "cannot-decode-prores";
+        }
+        return "cannot-decode";
+      }
+      const sampleSink = new VideoSampleSink(videoTrack);
+      const packetSink = new EncodedPacketSink(videoTrack);
+      const startPacket = await packetSink.getFirstPacket({
+        verifyKeyPackets: true
+      });
+      const hasAlpha = startPacket?.sideData.alpha;
+      if (hasAlpha && !canBrowserUseWebGl2()) {
+        Internals11.Log.warn({ logLevel, tag: "@remotion/media" }, `WebGL2 is not available, using the non-fast CPU path to decode alpha for ${src}.`);
+      }
+      return {
+        sampleSink
+      };
+    };
+    let videoSinksPromise = null;
+    const getVideoSinksPromise = () => {
+      if (videoSinksPromise) {
+        return videoSinksPromise;
+      }
+      videoSinksPromise = getVideoSinks();
+      return videoSinksPromise;
+    };
+    const audioSinksPromise = {};
+    const getAudioSinks = async (index) => {
+      if (format === null) {
+        return "unknown-container-format";
+      }
+      if (format === "network-error") {
+        return "network-error";
+      }
+      const [videoTrack, audioTracks] = await Promise.all([
+        input.getPrimaryVideoTrack(),
+        input.getAudioTracks()
+      ]);
+      const audioTrack = await resolveAudioTrack({
+        videoTrack,
+        audioTracks,
+        audioStreamIndex: index
+      });
+      if (!audioTrack) {
+        return "no-audio-track";
+      }
+      const canDecode = await audioTrack.canDecode();
+      if (!canDecode) {
+        return "cannot-decode-audio";
+      }
+      return {
+        sampleSink: new AudioSampleSink(audioTrack)
+      };
+    };
+    const getAudioSinksPromise = (index) => {
+      const keyIndex = index === null ? -1 : index;
+      if (audioSinksPromise[keyIndex]) {
+        return audioSinksPromise[keyIndex];
+      }
+      audioSinksPromise[keyIndex] = getAudioSinks(index);
+      return audioSinksPromise[keyIndex];
+    };
+    return {
+      getVideo: () => getVideoSinksPromise(),
+      getAudio: (index) => getAudioSinksPromise(index),
+      actualMatroskaTimestamps: rememberActualMatroskaTimestamps(isMatroska),
+      isMatroska,
+      getDuration: () => {
+        return getDurationOrCompute(input);
+      }
+    };
+  };
+  return {
+    promise: getSinks(),
+    dispose: () => input.dispose()
+  };
+};
+
+// src/get-sink.ts
+var getSinkCacheKey = ({
+  src,
+  credentials,
+  requestInit
+}) => JSON.stringify([
+  src,
+  credentials,
+  getMediaRequestInitFingerprint(requestInit)
+]);
+var makeSinkManager = () => {
+  const sinkPromises = {};
+  const inputDisposers = {};
+  let disposed = false;
+  return {
+    getSink: (src, logLevel, credentials, requestInit) => {
+      if (disposed) {
+        return Promise.reject(new Error("Media cache has already been disposed"));
+      }
+      const normalizedRequestInit = normalizeMediaRequestInit(requestInit);
+      const cacheKey = getSinkCacheKey({
+        src,
+        credentials,
+        requestInit: normalizedRequestInit
+      });
+      let promise = sinkPromises[cacheKey];
+      if (!promise) {
+        Internals12.Log.verbose({
+          logLevel,
+          tag: "@remotion/media"
+        }, `Sink for ${src} was not found, creating new sink`);
+        const sinks = makeSinks(src, logLevel, credentials, normalizedRequestInit);
+        promise = sinks.promise;
+        sinkPromises[cacheKey] = promise;
+        inputDisposers[cacheKey] = sinks.dispose;
+      }
+      return promise;
+    },
+    dispose: () => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      let firstError = null;
+      for (const cacheKey of Object.keys(inputDisposers)) {
+        try {
+          inputDisposers[cacheKey]();
+        } catch (error) {
+          firstError ??= error;
+        } finally {
+          delete inputDisposers[cacheKey];
+          delete sinkPromises[cacheKey];
+        }
+      }
+      if (firstError !== null) {
+        throw firstError;
+      }
+    }
+  };
+};
+
+// src/video-extraction/keyframe-manager.ts
+import { Internals as Internals14 } from "remotion";
+
 // src/render-timestamp-range.ts
 var renderTimestampRange = (timestamps) => {
   if (timestamps.length === 0) {
@@ -3143,12 +3475,13 @@ var renderTimestampRange = (timestamps) => {
 };
 
 // src/video-extraction/keyframe-bank.ts
-import { Internals as Internals10 } from "remotion";
+import { Internals as Internals13 } from "remotion";
 
 // src/video-extraction/get-allocation-size.ts
+var BYTES_PER_PIXEL_FOR_OPAQUE_FRAME = 3;
 var getAllocationSize = (sample) => {
   if (sample.format === null) {
-    return sample.codedHeight * sample.codedWidth * 4;
+    return sample.codedHeight * sample.codedWidth * BYTES_PER_PIXEL_FOR_OPAQUE_FRAME;
   }
   return sample.allocationSize();
 };
@@ -3167,6 +3500,7 @@ var makeKeyframeBank = async ({
   let hasReachedEndOfVideo = false;
   let lastUsed = Date.now();
   let allocationSize = 0;
+  let pendingOperations = 0;
   const getMeasuredDurationOfFrame = (timestamp) => {
     const index = frameTimestamps.indexOf(timestamp);
     if (index === -1) {
@@ -3222,7 +3556,7 @@ var makeKeyframeBank = async ({
       }
     }
     if (deletedTimestamps.length > 0) {
-      Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${deletedTimestamps.length} frame${deletedTimestamps.length === 1 ? "" : "s"} ${renderTimestampRange(deletedTimestamps)} for src ${src} because it is lower than ${timestampInSeconds}. Remaining: ${renderTimestampRange(frameTimestamps)}`);
+      Internals13.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${deletedTimestamps.length} frame${deletedTimestamps.length === 1 ? "" : "s"} ${renderTimestampRange(deletedTimestamps)} for src ${src} because it is lower than ${timestampInSeconds}. Remaining: ${renderTimestampRange(frameTimestamps)}`);
     }
   };
   const hasDecodedEnoughForTimestamp = (timestamp) => {
@@ -3251,7 +3585,7 @@ var makeKeyframeBank = async ({
     frameTimestamps.push(frame.timestamp);
     allocationSize += getAllocationSize(frame);
     lastUsed = Date.now();
-    Internals10.Log.trace({ logLevel, tag: "@remotion/media" }, `Added frame at ${frame.timestamp}sec to bank`);
+    Internals13.Log.trace({ logLevel, tag: "@remotion/media" }, `Added frame at ${frame.timestamp}sec to bank`);
   };
   const ensureEnoughFramesForTimestamp = async (timestampInSeconds, logLevel, fps) => {
     while (!hasDecodedEnoughForTimestamp(timestampInSeconds)) {
@@ -3306,7 +3640,7 @@ var makeKeyframeBank = async ({
     throw new Error("No first frame found");
   }
   const startTimestampInSeconds = firstFrame.value.timestamp;
-  Internals10.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec`);
+  Internals13.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec`);
   addFrame(firstFrame.value, parentLogLevel);
   const getRangeOfTimestamps = () => {
     if (frameTimestamps.length === 0) {
@@ -3323,7 +3657,7 @@ var makeKeyframeBank = async ({
   const prepareForDeletion = (logLevel, reason) => {
     const range = getRangeOfTimestamps();
     if (range) {
-      Internals10.Log.verbose({ logLevel, tag: "@remotion/media" }, `Preparing for deletion (${reason}) of keyframe bank from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec`);
+      Internals13.Log.verbose({ logLevel, tag: "@remotion/media" }, `Preparing for deletion (${reason}) of keyframe bank from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec`);
     }
     let framesDeleted = 0;
     for (const frameTimestamp of frameTimestamps.slice()) {
@@ -3364,12 +3698,18 @@ var makeKeyframeBank = async ({
   };
   const keyframeBank = {
     getFrameFromTimestamp: (timestamp, fps) => {
-      queue = queue.then(() => getFrameFromTimestamp(timestamp, fps));
+      pendingOperations++;
+      queue = queue.then(() => getFrameFromTimestamp(timestamp, fps)).finally(() => {
+        pendingOperations--;
+      });
       return queue;
     },
     prepareForDeletion,
     hasTimestampInSecond: (timestamp, fps) => {
-      queue = queue.then(() => hasTimestampInSecond(timestamp, fps));
+      pendingOperations++;
+      queue = queue.then(() => hasTimestampInSecond(timestamp, fps)).finally(() => {
+        pendingOperations--;
+      });
       return queue;
     },
     addFrame,
@@ -3377,6 +3717,7 @@ var makeKeyframeBank = async ({
     src,
     getOpenFrameCount,
     getLastUsed,
+    isBusy: () => pendingOperations > 0,
     canSatisfyTimestamp,
     getRangeOfTimestamps
   };
@@ -3384,11 +3725,26 @@ var makeKeyframeBank = async ({
 };
 
 // src/video-extraction/keyframe-manager.ts
-var makeKeyframeManager = () => {
+var RECENTLY_USED_REQUEST_COUNT = 50;
+var makeKeyframeManager = ({
+  getTotalCacheStats
+}) => {
   let sources = {};
-  const addKeyframeBank = ({ src, bank }) => {
+  let disposed = false;
+  let requestCountForSrc = {};
+  const lastRequestForBank = new WeakMap;
+  const addKeyframeBank = ({
+    src,
+    bank,
+    logLevel
+  }) => {
+    if (disposed) {
+      bank.prepareForDeletion(logLevel, "media cache was disposed");
+      return false;
+    }
     sources[src] = sources[src] ?? [];
     sources[src].push(bank);
+    return true;
   };
   const logCacheStats = (logLevel) => {
     let count = 0;
@@ -3401,10 +3757,10 @@ var makeKeyframeManager = () => {
         if (size === 0) {
           continue;
         }
-        Internals11.Log.verbose({ logLevel, tag: "@remotion/media" }, `Open frames for src ${src}: ${renderTimestampRange(timestamps)}`);
+        Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Open frames for src ${src}: ${renderTimestampRange(timestamps)}`);
       }
     }
-    Internals11.Log.verbose({ logLevel, tag: "@remotion/media" }, `Video cache stats: ${count} open frames, ${totalSize} bytes`);
+    Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Video cache stats: ${count} open frames, ${totalSize} bytes`);
   };
   const getCacheStats = () => {
     let count = 0;
@@ -3427,39 +3783,34 @@ var makeKeyframeManager = () => {
     let numberOfBanks = 0;
     for (const src in sources) {
       for (const bank of sources[src]) {
+        numberOfBanks++;
+        if (bank.isBusy()) {
+          continue;
+        }
         const index = sources[src].indexOf(bank);
         const lastUsed = bank.getLastUsed();
         if (mostInThePast === null || lastUsed < mostInThePast) {
           mostInThePast = lastUsed;
           mostInThePastBank = { src, bank, index };
         }
-        numberOfBanks++;
       }
     }
     if (!mostInThePastBank) {
-      throw new Error("No keyframe bank found");
+      return { mostInThePastBank: null, numberOfBanks };
     }
     return { mostInThePastBank, numberOfBanks };
   };
   const deleteOldestKeyframeBank = (logLevel) => {
-    const {
-      mostInThePastBank: {
-        bank: mostInThePastBank,
-        src: mostInThePastSrc,
-        index: mostInThePastIndex
-      },
-      numberOfBanks
-    } = getTheKeyframeBankMostInThePast();
-    if (numberOfBanks < 2) {
+    const { mostInThePastBank, numberOfBanks } = getTheKeyframeBankMostInThePast();
+    if (numberOfBanks < 2 || mostInThePastBank === null) {
       return { finish: true };
     }
-    if (mostInThePastBank) {
-      const range = mostInThePastBank.getRangeOfTimestamps();
-      const { framesDeleted } = mostInThePastBank.prepareForDeletion(logLevel, "deleted oldest keyframe bank to stay under max cache size");
-      sources[mostInThePastSrc].splice(mostInThePastIndex, 1);
-      if (range) {
-        Internals11.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${framesDeleted} frames for src ${mostInThePastSrc} from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec to free up memory.`);
-      }
+    const { bank, src, index } = mostInThePastBank;
+    const range = bank.getRangeOfTimestamps();
+    const { framesDeleted } = bank.prepareForDeletion(logLevel, "deleted oldest keyframe bank to stay under max cache size");
+    sources[src].splice(index, 1);
+    if (range) {
+      Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${framesDeleted} frames for src ${src} from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec to free up memory.`);
     }
     return { finish: false };
   };
@@ -3472,12 +3823,12 @@ var makeKeyframeManager = () => {
       if (finish) {
         break;
       }
-      Internals11.Log.verbose({ logLevel, tag: "@remotion/media" }, "Deleted oldest keyframe bank to stay under max cache size", (cacheStats.totalSize / 1024 / 1024).toFixed(1), "out of", (maxCacheSize / 1024 / 1024).toFixed(1));
+      Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, "Deleted oldest keyframe bank to stay under max cache size", (cacheStats.totalSize / 1024 / 1024).toFixed(1), "out of", (maxCacheSize / 1024 / 1024).toFixed(1));
       cacheStats = getTotalCacheStats();
       attempts++;
     }
     if (cacheStats.totalSize > maxCacheSize && attempts >= maxAttempts) {
-      Internals11.Log.warn({ logLevel, tag: "@remotion/media" }, `Exceeded max cache size after ${maxAttempts} attempts. Remaining cache size: ${(cacheStats.totalSize / 1024 / 1024).toFixed(1)} MB, target was ${(maxCacheSize / 1024 / 1024).toFixed(1)} MB.`);
+      Internals14.Log.warn({ logLevel, tag: "@remotion/media" }, `Exceeded max cache size after ${maxAttempts} attempts. Remaining cache size: ${(cacheStats.totalSize / 1024 / 1024).toFixed(1)} MB, target was ${(maxCacheSize / 1024 / 1024).toFixed(1)} MB.`);
     }
   };
   const clearKeyframeBanksBeforeTime = ({
@@ -3491,14 +3842,22 @@ var makeKeyframeManager = () => {
       return;
     }
     const banks = sources[src];
+    const currentRequest = requestCountForSrc[src] ?? 0;
     for (const bank of banks) {
+      if (bank.isBusy()) {
+        continue;
+      }
       const range = bank.getRangeOfTimestamps();
       if (!range) {
         continue;
       }
+      const lastRequest = lastRequestForBank.get(bank);
+      if (lastRequest !== undefined && currentRequest - lastRequest < RECENTLY_USED_REQUEST_COUNT) {
+        continue;
+      }
       if (range.lastTimestamp < threshold) {
         bank.prepareForDeletion(logLevel, "cleared before threshold " + threshold);
-        Internals11.Log.verbose({ logLevel, tag: "@remotion/media" }, `[Video] Cleared frames for src ${src} from ${range.firstTimestamp}sec to ${range.lastTimestamp}sec`);
+        Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `[Video] Cleared frames for src ${src} from ${range.firstTimestamp}sec to ${range.lastTimestamp}sec`);
         const bankIndex = banks.indexOf(bank);
         delete sources[src][bankIndex];
       } else {
@@ -3520,21 +3879,23 @@ var makeKeyframeManager = () => {
     const existingBanks = sources[src] ?? [];
     const existingBank = existingBanks?.find((bank) => bank.canSatisfyTimestamp(timestamp));
     if (!existingBank) {
-      Internals11.Log.trace({ logLevel, tag: "@remotion/media" }, `Creating new keyframe bank for src ${src} at timestamp ${timestamp}`);
+      Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, `Creating new keyframe bank for src ${src} at timestamp ${timestamp}`);
       const newKeyframeBank = await makeKeyframeBank({
         videoSampleSink,
         logLevel,
         src,
         initialTimestampRequest: timestamp
       });
-      addKeyframeBank({ src, bank: newKeyframeBank });
+      if (!addKeyframeBank({ src, bank: newKeyframeBank, logLevel })) {
+        return null;
+      }
       return newKeyframeBank;
     }
     if (existingBank.canSatisfyTimestamp(timestamp)) {
-      Internals11.Log.trace({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists and satisfies timestamp ${timestamp}`);
+      Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists and satisfies timestamp ${timestamp}`);
       return existingBank;
     }
-    Internals11.Log.verbose({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists but frame at time ${timestamp} does not exist anymore.`);
+    Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists but frame at time ${timestamp} does not exist anymore.`);
     existingBank.prepareForDeletion(logLevel, "already existed but evicted");
     sources[src] = sources[src].filter((bank) => bank !== existingBank);
     const replacementKeybank = await makeKeyframeBank({
@@ -3543,7 +3904,9 @@ var makeKeyframeManager = () => {
       logLevel,
       src
     });
-    addKeyframeBank({ src, bank: replacementKeybank });
+    if (!addKeyframeBank({ src, bank: replacementKeybank, logLevel })) {
+      return null;
+    }
     return replacementKeybank;
   };
   const requestKeyframeBank = async ({
@@ -3554,6 +3917,10 @@ var makeKeyframeManager = () => {
     maxCacheSize,
     fps
   }) => {
+    if (disposed) {
+      return null;
+    }
+    requestCountForSrc[src] = (requestCountForSrc[src] ?? 0) + 1;
     ensureToStayUnderMaxCacheSize(logLevel, maxCacheSize);
     clearKeyframeBanksBeforeTime({
       timestampInSeconds: timestamp,
@@ -3567,6 +3934,9 @@ var makeKeyframeManager = () => {
       src,
       logLevel
     });
+    if (keyframeBank) {
+      lastRequestForBank.set(keyframeBank, requestCountForSrc[src]);
+    }
     return keyframeBank;
   };
   const clearAll = (logLevel) => {
@@ -3579,6 +3949,14 @@ var makeKeyframeManager = () => {
       sources[src] = [];
     }
     sources = {};
+    requestCountForSrc = {};
+  };
+  const dispose = (logLevel) => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    clearAll(logLevel);
   };
   let queue = Promise.resolve(undefined);
   return {
@@ -3601,58 +3979,98 @@ var makeKeyframeManager = () => {
       return queue;
     },
     getCacheStats,
-    clearAll
+    clearAll,
+    dispose
   };
 };
 
 // src/caches.ts
 var getSafeWindowOfMonotonicity = (fps) => 0.2 * 30 / fps;
-var keyframeManager = makeKeyframeManager();
-var audioManager = makeAudioManager();
-var getTotalCacheStats = () => {
-  const keyframeManagerCacheStats = keyframeManager.getCacheStats();
-  const audioManagerCacheStats = audioManager.getCacheStats();
-  return {
-    count: keyframeManagerCacheStats.count + audioManagerCacheStats.count,
-    totalSize: keyframeManagerCacheStats.totalSize + audioManagerCacheStats.totalSize
+var makeMediaCache = () => {
+  const sinkManager = makeSinkManager();
+  const managerInstances = {
+    keyframe: null,
+    audio: null
   };
-};
-var getUncachedMaxCacheSize = (logLevel) => {
-  if (typeof window !== "undefined" && window.remotion_mediaCacheSizeInBytes !== undefined && window.remotion_mediaCacheSizeInBytes !== null) {
-    if (window.remotion_mediaCacheSizeInBytes < 240 * 1024 * 1024) {
-      cancelRender(new Error(`The minimum value for the "mediaCacheSizeInBytes" prop is 240MB (${240 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
-    }
-    if (window.remotion_mediaCacheSizeInBytes > 20000 * 1024 * 1024) {
-      cancelRender(new Error(`The maximum value for the "mediaCacheSizeInBytes" prop is 20GB (${20000 * 1024 * 1024}), got: ${window.remotion_mediaCacheSizeInBytes}`));
-    }
-    Internals12.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set using "mediaCacheSizeInBytes": ${(window.remotion_mediaCacheSizeInBytes / 1024 / 1024).toFixed(1)} MB`);
-    return window.remotion_mediaCacheSizeInBytes;
-  }
-  if (typeof window !== "undefined" && window.remotion_initialMemoryAvailable !== undefined && window.remotion_initialMemoryAvailable !== null) {
-    const value = window.remotion_initialMemoryAvailable / 2;
-    if (value < 500 * 1024 * 1024) {
-      Internals12.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on minimum value of 500MB (which is more than half of the available system memory!)`);
-      return 500 * 1024 * 1024;
+  const getCacheStats = () => {
+    const { keyframe: currentKeyframeManager, audio: currentAudioManager } = managerInstances;
+    if (currentKeyframeManager === null || currentAudioManager === null) {
+      throw new Error("Media cache managers have not been initialized");
     }
-    if (value > 20000 * 1024 * 1024) {
-      Internals12.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on maximum value of 20GB (which is less than half of the available system memory)`);
-      return 20000 * 1024 * 1024;
+    const keyframeManagerCacheStats = currentKeyframeManager.getCacheStats();
+    const audioManagerCacheStats = currentAudioManager.getCacheStats();
+    return {
+      count: keyframeManagerCacheStats.count + audioManagerCacheStats.count,
+      totalSize: keyframeManagerCacheStats.totalSize + audioManagerCacheStats.totalSize
+    };
+  };
+  const keyframeManagerInstance = makeKeyframeManager({
+    getTotalCacheStats: getCacheStats
+  });
+  const audioManagerInstance = makeAudioManager({
+    getTotalCacheStats: getCacheStats
+  });
+  managerInstances.keyframe = keyframeManagerInstance;
+  managerInstances.audio = audioManagerInstance;
+  let frameExtractionQueue = Promise.resolve(undefined);
+  let audioExtractionQueue = Promise.resolve(undefined);
+  let disposed = false;
+  return {
+    sinkManager,
+    keyframeManager: keyframeManagerInstance,
+    audioManager: audioManagerInstance,
+    getTotalCacheStats: getCacheStats,
+    isDisposed: () => disposed,
+    queueFrameExtraction: (extract) => {
+      const extraction = frameExtractionQueue.then(extract);
+      frameExtractionQueue = extraction.catch(() => {
+        return;
+      });
+      return extraction;
+    },
+    queueAudioExtraction: (extract) => {
+      const extraction = audioExtractionQueue.then(extract);
+      audioExtractionQueue = extraction.catch(() => {
+        return;
+      });
+      return extraction;
+    },
+    dispose: (logLevel) => {
+      if (disposed) {
+        return;
+      }
+      disposed = true;
+      try {
+        keyframeManagerInstance.dispose(logLevel);
+      } finally {
+        try {
+          audioManagerInstance.dispose();
+        } finally {
+          sinkManager.dispose();
+        }
+      }
     }
-    Internals12.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on available memory (50% of available memory): ${(value / 1024 / 1024).toFixed(1)} MB`);
-    return value;
-  }
-  return 1000 * 1000 * 1000;
+  };
 };
-var cachedMaxCacheSize = null;
-var getMaxVideoCacheSize = (logLevel) => {
-  if (cachedMaxCacheSize !== null) {
-    return cachedMaxCacheSize;
-  }
-  cachedMaxCacheSize = getUncachedMaxCacheSize(logLevel);
-  return cachedMaxCacheSize;
+var globalMediaCache = makeMediaCache();
+var useRenderMediaCache = (logLevel) => {
+  const renderResourceManager = React2.useContext(Internals15.RenderResourceManagerContext);
+  if (renderResourceManager === null) {
+    return globalMediaCache;
+  }
+  return renderResourceManager.getOrCreateResource({
+    key: "@remotion/media/cache",
+    create: () => {
+      const resource = makeMediaCache();
+      return {
+        resource,
+        dispose: () => resource.dispose(logLevel)
+      };
+    }
+  });
 };
 var useMaxMediaCacheSize = (logLevel) => {
-  const context = React2.useContext(Internals12.MaxMediaCacheSizeContext);
+  const context = React2.useContext(Internals15.MaxMediaCacheSizeContext);
   if (context === null) {
     return getMaxVideoCacheSize(logLevel);
   }
@@ -3905,205 +4323,6 @@ var combineAudioDataAndClosePrevious = (audioDataArray) => {
   };
 };
 
-// src/get-sink.ts
-import { Internals as Internals14 } from "remotion";
-
-// src/video-extraction/get-frames-since-keyframe.ts
-import {
-  ALL_FORMATS as ALL_FORMATS2,
-  AudioSampleSink,
-  EncodedPacketSink,
-  Input as Input2,
-  MATROSKA,
-  UrlSource as UrlSource2,
-  VideoSampleSink,
-  WEBM
-} from "mediabunny";
-import { Internals as Internals13 } from "remotion";
-
-// src/browser-can-use-webgl2.ts
-var browserCanUseWebGl2 = null;
-var browserCanUseWebGl2Uncached = () => {
-  const canvas = new OffscreenCanvas(1, 1);
-  const context = canvas.getContext("webgl2");
-  return context !== null;
-};
-var canBrowserUseWebGl2 = () => {
-  if (browserCanUseWebGl2 !== null) {
-    return browserCanUseWebGl2;
-  }
-  browserCanUseWebGl2 = browserCanUseWebGl2Uncached();
-  return browserCanUseWebGl2;
-};
-
-// src/video-extraction/remember-actual-matroska-timestamps.ts
-var rememberActualMatroskaTimestamps = (isMatroska) => {
-  const observations = [];
-  const observeTimestamp = (startTime) => {
-    if (!isMatroska) {
-      return;
-    }
-    observations.push(startTime);
-  };
-  const getRealTimestamp = (observedTimestamp) => {
-    if (!isMatroska) {
-      return observedTimestamp;
-    }
-    return observations.find((observation) => Math.abs(observedTimestamp - observation) < 0.001) ?? null;
-  };
-  return {
-    observeTimestamp,
-    getRealTimestamp
-  };
-};
-
-// src/video-extraction/get-frames-since-keyframe.ts
-var getRetryDelay = () => {
-  return null;
-};
-var getFormatOrNullOrNetworkError = async (input) => {
-  try {
-    return await input.getFormat();
-  } catch (err) {
-    if (isNetworkError(err)) {
-      return "network-error";
-    }
-    return null;
-  }
-};
-var getSinks = async (src, logLevel, credentials, requestInit) => {
-  const resolvedRequestInit = resolveRequestInit({ credentials, requestInit });
-  const input = new Input2({
-    formats: ALL_FORMATS2,
-    source: new UrlSource2(src, {
-      getRetryDelay,
-      ...resolvedRequestInit ? { requestInit: resolvedRequestInit } : undefined
-    })
-  });
-  const format = await getFormatOrNullOrNetworkError(input);
-  const isMatroska = format === MATROSKA || format === WEBM;
-  const getVideoSinks = async () => {
-    if (format === "network-error") {
-      return "network-error";
-    }
-    if (format === null) {
-      return "unknown-container-format";
-    }
-    const videoTrack = await input.getPrimaryVideoTrack();
-    if (!videoTrack) {
-      return "no-video-track";
-    }
-    if (await videoTrack.isLive()) {
-      throw new Error("Live streams are not currently supported by Remotion. Sorry! Source: " + src);
-    }
-    if (await videoTrack.isRelativeToUnixEpoch()) {
-      throw new Error("Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: " + src);
-    }
-    const canDecode = await videoTrack.canDecode();
-    if (!canDecode) {
-      if (videoTrack.codec === "prores") {
-        return "cannot-decode-prores";
-      }
-      return "cannot-decode";
-    }
-    const sampleSink = new VideoSampleSink(videoTrack);
-    const packetSink = new EncodedPacketSink(videoTrack);
-    const startPacket = await packetSink.getFirstPacket({
-      verifyKeyPackets: true
-    });
-    const hasAlpha = startPacket?.sideData.alpha;
-    if (hasAlpha && !canBrowserUseWebGl2()) {
-      Internals13.Log.warn({ logLevel, tag: "@remotion/media" }, `WebGL2 is not available, using the non-fast CPU path to decode alpha for ${src}.`);
-    }
-    return {
-      sampleSink
-    };
-  };
-  let videoSinksPromise = null;
-  const getVideoSinksPromise = () => {
-    if (videoSinksPromise) {
-      return videoSinksPromise;
-    }
-    videoSinksPromise = getVideoSinks();
-    return videoSinksPromise;
-  };
-  const audioSinksPromise = {};
-  const getAudioSinks = async (index) => {
-    if (format === null) {
-      return "unknown-container-format";
-    }
-    if (format === "network-error") {
-      return "network-error";
-    }
-    const [videoTrack, audioTracks] = await Promise.all([
-      input.getPrimaryVideoTrack(),
-      input.getAudioTracks()
-    ]);
-    const audioTrack = await resolveAudioTrack({
-      videoTrack,
-      audioTracks,
-      audioStreamIndex: index
-    });
-    if (!audioTrack) {
-      return "no-audio-track";
-    }
-    const canDecode = await audioTrack.canDecode();
-    if (!canDecode) {
-      return "cannot-decode-audio";
-    }
-    return {
-      sampleSink: new AudioSampleSink(audioTrack)
-    };
-  };
-  const getAudioSinksPromise = (index) => {
-    const keyIndex = index === null ? -1 : index;
-    if (audioSinksPromise[keyIndex]) {
-      return audioSinksPromise[keyIndex];
-    }
-    audioSinksPromise[keyIndex] = getAudioSinks(index);
-    return audioSinksPromise[keyIndex];
-  };
-  return {
-    getVideo: () => getVideoSinksPromise(),
-    getAudio: (index) => getAudioSinksPromise(index),
-    actualMatroskaTimestamps: rememberActualMatroskaTimestamps(isMatroska),
-    isMatroska,
-    getDuration: () => {
-      return getDurationOrCompute(input);
-    }
-  };
-};
-
-// src/get-sink.ts
-var sinkPromises = {};
-var getSinkCacheKey = ({
-  src,
-  credentials,
-  requestInit
-}) => JSON.stringify([
-  src,
-  credentials,
-  getMediaRequestInitFingerprint(requestInit)
-]);
-var getSink = (src, logLevel, credentials, requestInit) => {
-  const normalizedRequestInit = normalizeMediaRequestInit(requestInit);
-  const cacheKey = getSinkCacheKey({
-    src,
-    credentials,
-    requestInit: normalizedRequestInit
-  });
-  let promise = sinkPromises[cacheKey];
-  if (!promise) {
-    Internals14.Log.verbose({
-      logLevel,
-      tag: "@remotion/media"
-    }, `Sink for ${src} was not found, creating new sink`);
-    promise = getSinks(src, logLevel, credentials, normalizedRequestInit);
-    sinkPromises[cacheKey] = promise;
-  }
-  return promise;
-};
-
 // src/audio-extraction/extract-audio.ts
 var extractAudioInternal = async ({
   src,
@@ -4118,9 +4337,10 @@ var extractAudioInternal = async ({
   fps,
   maxCacheSize,
   credentials,
-  requestInit
+  requestInit,
+  mediaCache
 }) => {
-  const { getAudio, actualMatroskaTimestamps, isMatroska, getDuration } = await getSink(src, logLevel, credentials, requestInit);
+  const { getAudio, actualMatroskaTimestamps, isMatroska, getDuration } = await mediaCache.sinkManager.getSink(src, logLevel, credentials, requestInit);
   let mediaDurationInSeconds = null;
   if (loop) {
     mediaDurationInSeconds = await getDuration();
@@ -4153,7 +4373,7 @@ var extractAudioInternal = async ({
     return { data: null, durationInSeconds: mediaDurationInSeconds };
   }
   try {
-    const sampleIterator = await audioManager.getIterator({
+    const sampleIterator = await mediaCache.audioManager.getIterator({
       src,
       timeInSeconds,
       audioSampleSink: audio.sampleSink,
@@ -4164,7 +4384,7 @@ var extractAudioInternal = async ({
     });
     const durationInSeconds = durationNotYetApplyingPlaybackRate * playbackRate;
     const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
-    audioManager.logOpenFrames();
+    mediaCache.audioManager.logOpenFrames();
     const audioDataArray = [];
     for (let i = 0;i < samples.length; i++) {
       const sample = samples[i];
@@ -4229,14 +4449,12 @@ var extractAudioInternal = async ({
     throw err;
   }
 };
-var queue = Promise.resolve(undefined);
 var extractAudio = (params) => {
-  queue = queue.then(() => extractAudioInternal(params));
-  return queue;
+  return params.mediaCache.queueAudioExtraction(() => extractAudioInternal(params));
 };
 
 // src/video-extraction/extract-frame.ts
-import { Internals as Internals15 } from "remotion";
+import { Internals as Internals16 } from "remotion";
 var extractFrameInternal = async ({
   src,
   timeInSeconds: unloopedTimeInSeconds,
@@ -4248,9 +4466,10 @@ var extractFrameInternal = async ({
   fps,
   maxCacheSize,
   credentials,
-  requestInit
+  requestInit,
+  mediaCache
 }) => {
-  const sink = await getSink(src, logLevel, credentials, requestInit);
+  const sink = await mediaCache.sinkManager.getSink(src, logLevel, credentials, requestInit);
   const [video, mediaDurationInSecondsRaw] = await Promise.all([
     sink.getVideo(),
     loop ? sink.getDuration() : Promise.resolve(null)
@@ -4300,7 +4519,7 @@ var extractFrameInternal = async ({
     };
   }
   try {
-    const keyframeBank = await keyframeManager.requestKeyframeBank({
+    const keyframeBank = await mediaCache.keyframeManager.requestKeyframeBank({
       videoSampleSink: video.sampleSink,
       timestamp: timeInSeconds,
       src,
@@ -4325,14 +4544,12 @@ var extractFrameInternal = async ({
       durationInSeconds: await sink.getDuration()
     };
   } catch (err) {
-    Internals15.Log.info({ logLevel, tag: "@remotion/media" }, `Error decoding ${src} at time ${timeInSeconds}: ${err}`, err);
+    Internals16.Log.info({ logLevel, tag: "@remotion/media" }, `Error decoding ${src} at time ${timeInSeconds}: ${err}`, err);
     return { type: "cannot-decode", durationInSeconds: mediaDurationInSeconds };
   }
 };
-var queue2 = Promise.resolve(undefined);
 var extractFrame = (params) => {
-  queue2 = queue2.then(() => extractFrameInternal(params));
-  return queue2;
+  return params.mediaCache.queueFrameExtraction(() => extractFrameInternal(params));
 };
 
 // src/video-extraction/rotate-frame.ts
@@ -4384,7 +4601,8 @@ var extractFrameAndAudio = async ({
   fps,
   maxCacheSize,
   credentials,
-  requestInit
+  requestInit,
+  mediaCache
 }) => {
   try {
     const [video, audio] = await Promise.all([
@@ -4399,7 +4617,8 @@ var extractFrameAndAudio = async ({
         fps,
         maxCacheSize,
         credentials,
-        requestInit
+        requestInit,
+        mediaCache
       }) : null,
       includeAudio ? extractAudio({
         src,
@@ -4414,7 +4633,8 @@ var extractFrameAndAudio = async ({
         trimBefore,
         maxCacheSize,
         credentials,
-        requestInit
+        requestInit,
+        mediaCache
       }) : null
     ]);
     if (video?.type === "cannot-decode") {
@@ -4505,7 +4725,8 @@ var addBroadcastChannelListener = () => {
           fps: data.fps,
           maxCacheSize: data.maxCacheSize,
           credentials: data.credentials,
-          requestInit: data.requestInit
+          requestInit: data.requestInit,
+          mediaCache: globalMediaCache
         });
         if (result.type === "cannot-decode") {
           const cannotDecodeResponse = {
@@ -4613,7 +4834,8 @@ var extractFrameViaBroadcastChannel = async ({
   fps,
   maxCacheSize,
   credentials,
-  requestInit
+  requestInit,
+  mediaCache
 }) => {
   if (isClientSideRendering || window.remotion_isMainTab) {
     return extractFrameAndAudio({
@@ -4631,7 +4853,8 @@ var extractFrameViaBroadcastChannel = async ({
       fps,
       maxCacheSize,
       credentials,
-      requestInit
+      requestInit,
+      mediaCache
     });
   }
   await waitForMainTabToBeReady(window.remotion_broadcastChannel);
@@ -4760,13 +4983,13 @@ var AudioForRendering = ({
   credentials,
   requestInit
 }) => {
-  const defaultLogLevel = Internals16.useLogLevel();
+  const defaultLogLevel = Internals17.useLogLevel();
   const logLevel = overriddenLogLevel ?? defaultLogLevel;
   const frame = useCurrentFrame2();
-  const absoluteFrame = Internals16.useTimelinePosition();
-  const videoConfig = Internals16.useUnsafeVideoConfig();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext3(Internals16.RenderAssetManager);
-  const startsAt = Internals16.useMediaStartsAt();
+  const absoluteFrame = Internals17.useTimelinePosition();
+  const videoConfig = Internals17.useUnsafeVideoConfig();
+  const { registerRenderAsset, unregisterRenderAsset } = useContext3(Internals17.RenderAssetManager);
+  const startsAt = Internals17.useMediaStartsAt();
   const environment = useRemotionEnvironment();
   if (!videoConfig) {
     throw new Error("No video config found");
@@ -4778,7 +5001,7 @@ var AudioForRendering = ({
   const { delayRender, continueRender } = useDelayRender();
   const [replaceWithHtml5Audio, setReplaceWithHtml5Audio] = useState2(false);
   const [initialRequestInit] = useState2(requestInit);
-  const sequenceContext = useContext3(Internals16.SequenceContext);
+  const sequenceContext = useContext3(Internals17.SequenceContext);
   const id = useMemo2(() => `media-audio-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
@@ -4786,7 +5009,8 @@ var AudioForRendering = ({
     sequenceContext?.durationInFrames
   ]);
   const maxCacheSize = useMaxMediaCacheSize(logLevel);
-  const audioEnabled = Internals16.useAudioEnabled();
+  const mediaCache = useRenderMediaCache(logLevel);
+  const audioEnabled = Internals17.useAudioEnabled();
   useLayoutEffect2(() => {
     const timestamp = frame / fps;
     const durationInSeconds = 1 / fps;
@@ -4825,8 +5049,12 @@ var AudioForRendering = ({
       fps,
       maxCacheSize,
       credentials,
-      requestInit: initialRequestInit
+      requestInit: initialRequestInit,
+      mediaCache
     }).then((result) => {
+      if (mediaCache.isDisposed()) {
+        return;
+      }
       const handleError = (error, clientSideError, fallbackMessage) => {
         const [action, errorToUse] = callOnErrorAndResolve({
           onError,
@@ -4838,7 +5066,7 @@ var AudioForRendering = ({
         if (action === "fail") {
           cancelRender2(errorToUse);
         }
-        Internals16.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+        Internals17.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
         setReplaceWithHtml5Audio(true);
       };
       if (result.type === "unknown-container-format") {
@@ -4868,12 +5096,12 @@ var AudioForRendering = ({
         frame,
         startsAt
       });
-      const volume = Internals16.evaluateVolume({
+      const volume = Internals17.evaluateVolume({
         volume: volumeProp,
         frame: volumePropsFrame,
         mediaVolume: 1
       });
-      Internals16.warnAboutTooHighVolume(volume);
+      Internals17.warnAboutTooHighVolume(volume);
       if (audio && volume > 0) {
         applyVolume(audio.data, volume);
         registerRenderAsset({
@@ -4888,6 +5116,9 @@ var AudioForRendering = ({
       }
       continueRender(newHandle);
     }).catch((error) => {
+      if (mediaCache.isDisposed()) {
+        return;
+      }
       cancelRender2(error);
     });
     return () => {
@@ -4924,7 +5155,8 @@ var AudioForRendering = ({
     audioEnabled,
     onError,
     credentials,
-    initialRequestInit
+    initialRequestInit,
+    mediaCache
   ]);
   if (replaceWithHtml5Audio) {
     return /* @__PURE__ */ jsx2(Html5Audio, {
@@ -4952,7 +5184,7 @@ var AudioForRendering = ({
 
 // src/audio/audio.tsx
 import { jsx as jsx3 } from "react/jsx-runtime";
-var { validateMediaProps } = Internals17;
+var { validateMediaProps } = Internals18;
 var audioSchema = {
   src: {
     type: "asset",
@@ -4960,8 +5192,8 @@ var audioSchema = {
     description: "Source",
     keyframable: false
   },
-  ...Internals17.baseSchema,
-  ...Internals17.premountSchema,
+  ...Internals18.baseSchema,
+  ...Internals18.premountSchema,
   volume: {
     type: "number",
     min: 0,
@@ -4997,12 +5229,12 @@ var AudioInner = (props) => {
     ...otherProps
   } = props;
   const environment = useRemotionEnvironment2();
-  const sourceStack = controls ? Internals17.getStackForControls(controls) : null;
-  const [mediaVolume] = Internals17.useMediaVolumeState();
-  const mediaStartsAt = Internals17.useMediaStartsAt();
+  const sourceStack = controls ? Internals18.getStackForControls(controls) : null;
+  const [mediaVolume] = Internals18.useMediaVolumeState();
+  const mediaStartsAt = Internals18.useMediaStartsAt();
   const videoConfig = useVideoConfig2();
   const sequenceDurationInFrames = Math.min(durationInFrames ?? Infinity, Math.max(0, videoConfig.durationInFrames - (from ?? 0)));
-  const basicInfo = Internals17.useBasicMediaInTimeline({
+  const basicInfo = Internals18.useBasicMediaInTimeline({
     src: props.src,
     volume: props.volume,
     playbackRate: props.playbackRate ?? 1,
@@ -5045,7 +5277,7 @@ var AudioInner = (props) => {
     postmountingActive,
     premountingActive,
     premountingStyle
-  } = Internals17.usePremounting({
+  } = Internals18.usePremounting({
     from: from ?? 0,
     durationInFrames: basicInfo.duration,
     premountFor: premountFor ?? null,
@@ -5106,7 +5338,7 @@ var Audio = Interactive.withSchema({
 import React6, { useMemo as useMemo6, useState as useState6 } from "react";
 import {
   Freeze as Freeze2,
-  Internals as Internals22,
+  Internals as Internals23,
   Interactive as Interactive2,
   Sequence as Sequence2,
   useRemotionEnvironment as useRemotionEnvironment4,
@@ -5114,7 +5346,7 @@ import {
 } from "remotion";
 
 // src/video/get-video-sequence-duration.ts
-import { Internals as Internals18 } from "remotion";
+import { Internals as Internals19 } from "remotion";
 var getVideoSequenceDuration = ({
   durationInFrames,
   loop,
@@ -5125,7 +5357,7 @@ var getVideoSequenceDuration = ({
   if (loop || trimAfter === undefined) {
     return durationInFrames;
   }
-  const trimmedDuration = Internals18.calculateMediaDuration({
+  const trimmedDuration = Internals19.calculateMediaDuration({
     trimAfter,
     trimBefore,
     playbackRate,
@@ -5146,7 +5378,7 @@ import {
 } from "react";
 import {
   Html5Video,
-  Internals as Internals20,
+  Internals as Internals21,
   useBufferState as useBufferState2,
   useCurrentFrame as useCurrentFrame3,
   useVideoConfig as useVideoConfig3
@@ -5189,7 +5421,7 @@ var getCachedVideoFrame = (src) => {
 };
 
 // src/video/warn-object-fit-css.ts
-import { Internals as Internals19 } from "remotion";
+import { Internals as Internals20 } from "remotion";
 var OBJECT_FIT_CLASS_PATTERN = /\bobject-(contain|cover|fill|none|scale-down)\b/;
 var warnedStyle = false;
 var warnedClassName = false;
@@ -5200,11 +5432,11 @@ var warnAboutObjectFitInStyleOrClassName = ({
 }) => {
   if (!warnedStyle && style?.objectFit) {
     warnedStyle = true;
-    Internals19.Log.warn({ logLevel, tag: "@remotion/media" }, "Use the `objectFit` prop instead of the `style` prop.");
+    Internals20.Log.warn({ logLevel, tag: "@remotion/media" }, "Use the `objectFit` prop instead of the `style` prop.");
   }
   if (!warnedClassName && className && OBJECT_FIT_CLASS_PATTERN.test(className)) {
     warnedClassName = true;
-    Internals19.Log.warn({ logLevel, tag: "@remotion/media" }, "Use the `objectFit` prop instead of `object-*` CSS class names.");
+    Internals20.Log.warn({ logLevel, tag: "@remotion/media" }, "Use the `objectFit` prop instead of `object-*` CSS class names.");
   }
 };
 
@@ -5222,7 +5454,7 @@ var {
   usePreload: usePreload2,
   SequenceContext: SequenceContext2,
   useEffectChainState
-} = Internals20;
+} = Internals21;
 var VideoForPreviewAssertedShowing = ({
   src: unpreloadedSrc,
   style,
@@ -5265,7 +5497,7 @@ var VideoForPreviewAssertedShowing = ({
   const [mediaPlayerReady, setMediaPlayerReady] = useState4(false);
   const [shouldFallbackToNativeVideo, setShouldFallbackToNativeVideo] = useState4(false);
   const [playing] = Timeline2.usePlayingState();
-  const { playbackRate: globalPlaybackRate } = Internals20.usePlaybackRate();
+  const { playbackRate: globalPlaybackRate } = Internals21.usePlaybackRate();
   const sharedAudioContext = useContext4(SharedAudioContext2);
   const buffer = useBufferState2();
   const canvasRefCallback = useCallback((canvas) => {
@@ -5302,12 +5534,12 @@ var VideoForPreviewAssertedShowing = ({
   const currentTimeRef = useRef2(currentTime);
   currentTimeRef.current = currentTime;
   const preloadedSrc = usePreload2(src);
-  const buffering = useContext4(Internals20.BufferingContextReact);
+  const buffering = useContext4(Internals21.BufferingContextReact);
   if (!buffering) {
     throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
   }
   const effectiveMuted = muted || playerMuted || userPreferredVolume <= 0;
-  const isPlayerBuffering = Internals20.useIsPlayerBuffering(buffering);
+  const isPlayerBuffering = Internals21.useIsPlayerBuffering(buffering);
   const initialPlaying = useRef2(playing && !isPlayerBuffering);
   const initialIsPremounting = useRef2(isPremounting);
   const initialIsPostmounting = useRef2(isPostmounting);
@@ -5405,7 +5637,7 @@ var VideoForPreviewAssertedShowing = ({
           if (action === "fail") {
             throw errorToUse;
           }
-          Internals20.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+          Internals21.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
           setShouldFallbackToNativeVideo(true);
         };
         if (result.type === "unknown-container-format") {
@@ -5447,7 +5679,7 @@ var VideoForPreviewAssertedShowing = ({
         if (action === "fail") {
           throw errorToUse;
         }
-        Internals20.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] Failed to initialize MediaPlayer", errorToUse);
+        Internals21.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] Failed to initialize MediaPlayer", errorToUse);
         setShouldFallbackToNativeVideo(true);
       });
     } catch (error) {
@@ -5461,12 +5693,12 @@ var VideoForPreviewAssertedShowing = ({
       if (action === "fail") {
         throw errorToUse;
       }
-      Internals20.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer initialization failed", errorToUse);
+      Internals21.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer initialization failed", errorToUse);
       setShouldFallbackToNativeVideo(true);
     }
     return () => {
       if (mediaPlayerRef.current) {
-        Internals20.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Disposing MediaPlayer`);
+        Internals21.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Disposing MediaPlayer`);
         mediaPlayerRef.current.dispose();
         mediaPlayerRef.current = null;
       }
@@ -5490,7 +5722,7 @@ var VideoForPreviewAssertedShowing = ({
   ]);
   warnAboutObjectFitInStyleOrClassName({ style, className, logLevel });
   const classNameValue = useMemo4(() => {
-    return [Internals20.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals20.truthy).join(" ");
+    return [Internals21.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals21.truthy).join(" ");
   }, [className]);
   useCommonEffects({
     mediaPlayerRef,
@@ -5614,7 +5846,7 @@ import {
   useState as useState5
 } from "react";
 import {
-  Internals as Internals21,
+  Internals as Internals22,
   Loop,
   random as random2,
   useCurrentFrame as useCurrentFrame4,
@@ -5655,11 +5887,11 @@ var VideoForRendering = ({
     throw new TypeError("No `src` was passed to <Video>.");
   }
   const frame = useCurrentFrame4();
-  const absoluteFrame = Internals21.useTimelinePosition();
+  const absoluteFrame = Internals22.useTimelinePosition();
   const { fps } = useVideoConfig4();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext5(Internals21.RenderAssetManager);
-  const startsAt = Internals21.useMediaStartsAt();
-  const sequenceContext = useContext5(Internals21.SequenceContext);
+  const { registerRenderAsset, unregisterRenderAsset } = useContext5(Internals22.RenderAssetManager);
+  const startsAt = Internals22.useMediaStartsAt();
+  const sequenceContext = useContext5(Internals22.SequenceContext);
   const id = useMemo5(() => `media-video-${random2(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
@@ -5671,10 +5903,11 @@ var VideoForRendering = ({
   const canvasRef = useRef3(null);
   const [replaceWithOffthreadVideo, setReplaceWithOffthreadVideo] = useState5(false);
   const [initialRequestInit] = useState5(requestInit);
-  const audioEnabled = Internals21.useAudioEnabled();
-  const videoEnabled = Internals21.useVideoEnabled();
+  const audioEnabled = Internals22.useAudioEnabled();
+  const videoEnabled = Internals22.useVideoEnabled();
   const maxCacheSize = useMaxMediaCacheSize(logLevel);
-  const effectChainState = Internals21.useEffectChainState();
+  const mediaCache = useRenderMediaCache(logLevel);
+  const effectChainState = Internals22.useEffectChainState();
   const [error, setError] = useState5(null);
   if (error) {
     throw error;
@@ -5720,8 +5953,15 @@ var VideoForRendering = ({
       fps,
       maxCacheSize,
       credentials,
-      requestInit: initialRequestInit
+      requestInit: initialRequestInit,
+      mediaCache
     }).then(async (result) => {
+      if (mediaCache.isDisposed()) {
+        if (result.type === "success") {
+          result.frame?.close();
+        }
+        return;
+      }
       const handleError = (err, clientSideError, fallbackMessage, mediaDurationInSeconds) => {
         if (environment.isClientSideRendering) {
           cancelRender3(clientSideError);
@@ -5739,7 +5979,7 @@ var VideoForRendering = ({
           return;
         }
         if (window.remotion_isMainTab) {
-          Internals21.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+          Internals22.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
         }
         setReplaceWithOffthreadVideo({
           durationInSeconds: mediaDurationInSeconds
@@ -5783,7 +6023,7 @@ var VideoForRendering = ({
           context.canvas.style.aspectRatio = `${context.canvas.width} / ${context.canvas.height}`;
           context.drawImage(imageBitmap, 0, 0);
           if (effects.length > 0) {
-            const completed = await Internals21.runEffectChain({
+            const completed = await Internals22.runEffectChain({
               state: effectChainState.get(imageBitmap.width, imageBitmap.height),
               source: context.canvas,
               effects,
@@ -5791,7 +6031,7 @@ var VideoForRendering = ({
               width: imageBitmap.width,
               height: imageBitmap.height
             });
-            if (!completed) {
+            if (!completed || mediaCache.isDisposed()) {
               imageBitmap.close();
               return;
             }
@@ -5814,12 +6054,12 @@ var VideoForRendering = ({
         frame,
         startsAt
       });
-      const volume = Internals21.evaluateVolume({
+      const volume = Internals22.evaluateVolume({
         volume: volumeProp,
         frame: volumePropsFrame,
         mediaVolume: 1
       });
-      Internals21.warnAboutTooHighVolume(volume);
+      Internals22.warnAboutTooHighVolume(volume);
       if (audio && volume > 0) {
         applyVolume(audio.data, volume);
         registerRenderAsset({
@@ -5834,6 +6074,9 @@ var VideoForRendering = ({
       }
       continueRender(newHandle);
     }).catch((err) => {
+      if (mediaCache.isDisposed()) {
+        return;
+      }
       cancelRender3(err);
     });
     return () => {
@@ -5876,11 +6119,12 @@ var VideoForRendering = ({
     credentials,
     effectChainState,
     effects,
-    initialRequestInit
+    initialRequestInit,
+    mediaCache
   ]);
   warnAboutObjectFitInStyleOrClassName({ style, className, logLevel });
   const classNameValue = useMemo5(() => {
-    return [Internals21.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals21.truthy).join(" ");
+    return [Internals22.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals22.truthy).join(" ");
   }, [className]);
   const styleWithObjectFit = useMemo5(() => {
     return {
@@ -5889,7 +6133,7 @@ var VideoForRendering = ({
     };
   }, [objectFitProp, style]);
   if (replaceWithOffthreadVideo) {
-    const fallback = /* @__PURE__ */ jsx5(Internals21.InnerOffthreadVideo, {
+    const fallback = /* @__PURE__ */ jsx5(Internals22.InnerOffthreadVideo, {
       ...props,
       src,
       playbackRate: playbackRate ?? 1,
@@ -5931,7 +6175,7 @@ var VideoForRendering = ({
       }
       return /* @__PURE__ */ jsx5(Loop, {
         layout: "none",
-        durationInFrames: Internals21.calculateMediaDuration({
+        durationInFrames: Internals22.calculateMediaDuration({
           trimAfter: trimAfterValue,
           mediaDurationInFrames: replaceWithOffthreadVideo.durationInSeconds * fps,
           playbackRate,
@@ -5960,7 +6204,7 @@ var {
   resolveTrimProps,
   validateMediaProps: validateMediaProps2,
   useCropStyle
-} = Internals22;
+} = Internals23;
 var videoSchema = {
   src: {
     type: "asset",
@@ -5968,8 +6212,8 @@ var videoSchema = {
     description: "Source",
     keyframable: false
   },
-  ...Internals22.baseSchema,
-  ...Internals22.premountSchema,
+  ...Internals23.baseSchema,
+  ...Internals23.premountSchema,
   volume: {
     type: "number",
     min: 0,
@@ -5990,7 +6234,7 @@ var videoSchema = {
   },
   muted: { type: "boolean", default: false, description: "Muted" },
   loop: { type: "boolean", default: false, description: "Loop" },
-  ...Internals22.transformSchema,
+  ...Internals23.transformSchema,
   ...Interactive2.backgroundSchema,
   ...Interactive2.borderSchema,
   ...Interactive2.borderRadiusSchema,
@@ -6153,10 +6397,10 @@ var VideoInner = ({
   cropBottom,
   ...props
 }) => {
-  const sourceStack = controls ? Internals22.getStackForControls(controls) ?? undefined : undefined;
-  const fallbackLogLevel = Internals22.useLogLevel();
-  const [mediaVolume] = Internals22.useMediaVolumeState();
-  const mediaStartsAt = Internals22.useMediaStartsAt();
+  const sourceStack = controls ? Internals23.getStackForControls(controls) ?? undefined : undefined;
+  const fallbackLogLevel = Internals23.useLogLevel();
+  const [mediaVolume] = Internals23.useMediaVolumeState();
+  const mediaStartsAt = Internals23.useMediaStartsAt();
   const videoConfig = useVideoConfig5();
   const sequenceDurationInFrames = Math.min(durationInFrames ?? Infinity, Math.max(0, videoConfig.durationInFrames - (from ?? 0)));
   const videoSequenceDuration = getVideoSequenceDuration({
@@ -6166,7 +6410,7 @@ var VideoInner = ({
     trimAfter,
     trimBefore
   });
-  const basicInfo = Internals22.useBasicMediaInTimeline({
+  const basicInfo = Internals23.useBasicMediaInTimeline({
     src,
     volume,
     playbackRate: playbackRate ?? 1,
@@ -6201,11 +6445,11 @@ var VideoInner = ({
     type: "video",
     data: basicInfo
   }), [basicInfo]);
-  const memoizedEffects = Internals22.useMemoizedEffects({
+  const memoizedEffects = Internals23.useMemoizedEffects({
     effects: effects ?? [],
     overrideId: controls?.overrideId ?? null
   });
-  const memoizedEffectDefinitions = Internals22.useMemoizedEffectDefinitions(effects ?? []);
+  const memoizedEffectDefinitions = Internals23.useMemoizedEffectDefinitions(effects ?? []);
   const refForOutline = React6.useRef(null);
   const {
     effectivePostmountFor,
@@ -6215,7 +6459,7 @@ var VideoInner = ({
     postmountingActive,
     premountingActive,
     premountingStyle
-  } = Internals22.usePremounting({
+  } = Internals23.usePremounting({
     from: from ?? 0,
     durationInFrames: videoSequenceDuration ?? Infinity,
     premountFor: premountFor ?? null,