@remotion/media 4.0.451 → 4.0.453

package/dist/esm/index.mjs

@@ -37,15 +37,15 @@ var __callDispose = (stack, error, hasError) => {
 };
 
 // src/audio/audio.tsx
-import { Internals as Internals19, Sequence, useRemotionEnvironment as useRemotionEnvironment2 } from "remotion";
+import { Internals as Internals17, Sequence, useRemotionEnvironment as useRemotionEnvironment2 } from "remotion";
 
 // src/audio/audio-for-preview.tsx
 import { useContext as useContext3, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
 import {
-  Internals as Internals10,
+  Internals as Internals8,
   Audio as RemotionAudio,
   useBufferState,
-  useCurrentFrame as useCurrentFrame2,
+  useCurrentFrame,
   useVideoConfig as useVideoConfig2
 } from "remotion";
 
@@ -102,219 +102,123 @@ var calculateEndTime = ({
 
 // src/media-player.ts
 import { ALL_FORMATS, Input, UrlSource } from "mediabunny";
-import { Internals as Internals6 } from "remotion";
+import { Internals as Internals4 } from "remotion";
 
 // src/audio-iterator-manager.ts
 import { AudioBufferSink, InputDisposedError } from "mediabunny";
-import { Internals as Internals4 } from "remotion";
-
-// src/audio/audio-preview-iterator.ts
-import { Internals as Internals3 } from "remotion";
-
-// src/helpers/round-to-4-digits.ts
-var roundTo4Digits = (timestamp) => {
-  return Math.round(timestamp * 1000) / 1000;
-};
-
-// src/set-global-time-anchor.ts
 import { Internals as Internals2 } from "remotion";
-var ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT = 0.1;
-var setGlobalTimeAnchor = ({
-  audioContext,
-  audioSyncAnchor,
-  absoluteTimeInSeconds,
-  globalPlaybackRate,
-  debugAudioScheduling,
-  logLevel
-}) => {
-  const newAnchor = audioContext.currentTime - absoluteTimeInSeconds / globalPlaybackRate;
-  const shift = (newAnchor - audioSyncAnchor.value) * globalPlaybackRate;
-  if (Math.abs(shift) < ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT) {
-    return;
+
+// src/make-iterator-with-priming.ts
+var AUDIO_PRIMING_SECONDS = 0.5;
+async function* makeIteratorWithPrimingInner(audioSink, timeToSeek, maximumTimestamp) {
+  const primingStart = Math.max(0, timeToSeek - AUDIO_PRIMING_SECONDS);
+  const iterator = audioSink.buffers(primingStart, maximumTimestamp);
+  for await (const buffer of iterator) {
+    if (buffer.timestamp + buffer.duration <= timeToSeek) {
+      continue;
+    }
+    yield {
+      buffer,
+      timestamp: buffer.timestamp
+    };
   }
-  if (debugAudioScheduling) {
-    Internals2.Log.info({ logLevel, tag: "audio-scheduling" }, "Anchor changed from %s to %s with shift %s", audioSyncAnchor.value, newAnchor, shift);
+}
+async function* makeLoopingIterator({
+  audioSink,
+  segmentStartInSeconds,
+  segmentEndInSeconds,
+  playbackRate,
+  sequenceDurationInSeconds
+}) {
+  const duration = segmentEndInSeconds - segmentStartInSeconds;
+  let iteration = 0;
+  let broken = false;
+  while (true) {
+    for await (const item of makeIteratorWithPrimingInner(audioSink, segmentStartInSeconds, segmentEndInSeconds)) {
+      const timestamp = item.timestamp + iteration * duration;
+      const endTimestamp = duration * iteration + (item.timestamp - segmentStartInSeconds + item.buffer.duration);
+      if (endTimestamp > sequenceDurationInSeconds * playbackRate) {
+        broken = true;
+        break;
+      }
+      yield {
+        buffer: item.buffer,
+        timestamp
+      };
+    }
+    if (broken) {
+      break;
+    }
+    iteration++;
   }
-  audioSyncAnchor.value = newAnchor;
+}
+var makeIteratorWithPriming = ({
+  audioSink,
+  timeToSeek,
+  maximumTimestamp,
+  loop,
+  playbackRate,
+  sequenceDurationInSeconds
+}) => {
+  if (loop) {
+    return makeLoopingIterator({
+      audioSink,
+      segmentStartInSeconds: timeToSeek,
+      segmentEndInSeconds: maximumTimestamp,
+      playbackRate,
+      sequenceDurationInSeconds
+    });
+  }
+  return makeIteratorWithPrimingInner(audioSink, timeToSeek, maximumTimestamp);
 };
 
 // src/audio/audio-preview-iterator.ts
+var ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT = 0.1;
 var makeAudioIterator = ({
   startFromSecond,
   maximumTimestamp,
-  cache,
-  debugAudioScheduling
+  audioSink,
+  loop,
+  playbackRate,
+  sequenceDurationInSeconds,
+  unscheduleAudioNode
 }) => {
   let destroyed = false;
-  const iterator = cache.makeIteratorOrUsePrewarmed(startFromSecond, maximumTimestamp);
+  const iterator = makeIteratorWithPriming({
+    audioSink,
+    timeToSeek: startFromSecond,
+    maximumTimestamp,
+    loop,
+    playbackRate,
+    sequenceDurationInSeconds
+  });
   const queuedAudioNodes = [];
-  const audioChunksForAfterResuming = [];
   let mostRecentTimestamp = -Infinity;
-  let pendingNext = null;
-  const cleanupAudioQueue = (audioContext) => {
+  const cleanupAudioQueue = () => {
     for (const node of queuedAudioNodes) {
+      unscheduleAudioNode(node.node);
       try {
-        const isAlreadyPlaying = node.scheduledTime - ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT < audioContext.audioContext.currentTime;
-        const wasScheduledForThisAnchor = node.scheduledAtAnchor === audioContext.audioSyncAnchor.value;
-        if (isAlreadyPlaying && wasScheduledForThisAnchor) {
-          continue;
-        }
-        if (debugAudioScheduling) {
-          const currentlyHearing = audioContext.audioContext.getOutputTimestamp().contextTime;
-          const nodeEndTime = node.scheduledTime + node.buffer.duration / node.playbackRate;
-          Internals3.Log.info({ logLevel: "trace", tag: "audio-scheduling" }, `Stopping node ${node.timestamp.toFixed(3)}, currently hearing = ${currentlyHearing.toFixed(3)} currentTime = ${audioContext.audioContext.currentTime.toFixed(3)} nodeEndTime = ${nodeEndTime.toFixed(3)} scheduledTime = ${node.scheduledTime.toFixed(3)}`);
-        }
         node.node.stop();
       } catch {}
     }
     queuedAudioNodes.length = 0;
   };
-  const getNextOrNullIfNotAvailable = async () => {
-    let next = pendingNext;
-    if (!next) {
-      next = iterator.next();
-    }
-    pendingNext = null;
-    const result = await Promise.race([
-      next,
-      new Promise((resolve) => {
-        Promise.resolve().then(() => resolve());
-      })
-    ]);
-    if (!result) {
-      pendingNext = next;
-      return {
-        type: "need-to-wait-for-it",
-        waitPromise: async () => {
-          const res = await next;
-          return res.value;
-        }
-      };
+  const getNextFn = async () => {
+    const next = await iterator.next();
+    if (next.value) {
+      mostRecentTimestamp = Math.max(mostRecentTimestamp, next.value.timestamp + next.value.buffer.duration);
     }
-    if (result.value) {
-      mostRecentTimestamp = Math.max(mostRecentTimestamp, result.value.timestamp + result.value.duration);
-      pendingNext = iterator.next();
-      return {
-        type: "got-buffer",
-        buffer: result.value
-      };
-    }
-    return {
-      type: "got-end",
-      mostRecentTimestamp
-    };
-  };
-  const tryToSatisfySeek = async (time, onBufferScheduled) => {
-    if (time < startFromSecond) {
-      return {
-        type: "not-satisfied",
-        reason: `time requested is before the start of the iterator`
-      };
-    }
-    while (true) {
-      const buffer = await getNextOrNullIfNotAvailable();
-      if (buffer.type === "need-to-wait-for-it") {
-        return {
-          type: "not-satisfied",
-          reason: "iterator did not have buffer ready"
-        };
-      }
-      if (buffer.type === "got-end") {
-        if (time >= mostRecentTimestamp) {
-          return {
-            type: "ended"
-          };
-        }
-        return {
-          type: "not-satisfied",
-          reason: `iterator ended before the requested time`
-        };
-      }
-      if (buffer.type === "got-buffer") {
-        const bufferTimestamp = roundTo4Digits(buffer.buffer.timestamp);
-        const bufferEndTimestamp = roundTo4Digits(buffer.buffer.timestamp + buffer.buffer.duration);
-        const timestamp = roundTo4Digits(time);
-        if (timestamp < bufferTimestamp) {
-          return {
-            type: "not-satisfied",
-            reason: `iterator is too far, most recently returned ${bufferTimestamp}-${bufferEndTimestamp}, requested ${timestamp}`
-          };
-        }
-        if (bufferTimestamp <= timestamp && bufferEndTimestamp >= timestamp) {
-          onBufferScheduled(buffer.buffer);
-          return {
-            type: "satisfied"
-          };
-        }
-        onBufferScheduled(buffer.buffer);
-        continue;
-      }
-      throw new Error("Unreachable");
-    }
-  };
-  const bufferAsFarAsPossible = async (onBufferScheduled, maxTimestamp) => {
-    while (true) {
-      if (mostRecentTimestamp >= maxTimestamp) {
-        return { type: "max-reached" };
-      }
-      const buffer = await getNextOrNullIfNotAvailable();
-      if (buffer.type === "need-to-wait-for-it") {
-        return { type: "waiting" };
-      }
-      if (buffer.type === "got-end") {
-        return { type: "ended" };
-      }
-      if (buffer.type === "got-buffer") {
-        onBufferScheduled(buffer.buffer);
-        continue;
-      }
-      throw new Error("Unreachable");
-    }
-  };
-  const removeAndReturnAllQueuedAudioNodes = () => {
-    const nodes = queuedAudioNodes.slice();
-    for (const node of nodes) {
-      try {
-        node.node.stop();
-      } catch {}
-    }
-    queuedAudioNodes.length = 0;
-    return nodes;
-  };
-  const addChunkForAfterResuming = (buffer, timestamp) => {
-    audioChunksForAfterResuming.push({
-      buffer,
-      timestamp
-    });
-  };
-  const moveQueuedChunksToPauseQueue = () => {
-    const toQueue = removeAndReturnAllQueuedAudioNodes();
-    for (const chunk of toQueue) {
-      addChunkForAfterResuming(chunk.buffer, chunk.timestamp);
-    }
-    if (debugAudioScheduling && toQueue.length > 0) {
-      Internals3.Log.trace({ logLevel: "trace", tag: "audio-scheduling" }, `Moved ${toQueue.length} ${toQueue.length === 1 ? "chunk" : "chunks"} to pause queue (${toQueue[0].timestamp.toFixed(3)}-${toQueue[toQueue.length - 1].timestamp + toQueue[toQueue.length - 1].buffer.duration.toFixed(3)})`);
-    }
-  };
-  const getNumberOfChunksAfterResuming = () => {
-    return audioChunksForAfterResuming.length;
+    return next;
   };
   return {
-    destroy: (audioContext) => {
-      cleanupAudioQueue(audioContext);
+    destroy: () => {
+      cleanupAudioQueue();
       destroyed = true;
       iterator.return().catch(() => {
         return;
       });
-      audioChunksForAfterResuming.length = 0;
-    },
-    getNext: async () => {
-      const next = await iterator.next();
-      if (next.value) {
-        mostRecentTimestamp = Math.max(mostRecentTimestamp, next.value.timestamp + next.value.duration);
-      }
-      return next;
     },
+    getNextFn,
     isDestroyed: () => {
       return destroyed;
     },
@@ -323,7 +227,6 @@ var makeAudioIterator = ({
       timestamp,
       buffer,
       scheduledTime,
-      playbackRate,
       scheduledAtAnchor
     }) => {
       queuedAudioNodes.push({
@@ -335,16 +238,8 @@ var makeAudioIterator = ({
         scheduledAtAnchor
       });
     },
-    removeQueuedAudioNode: (node) => {
-      const index = queuedAudioNodes.findIndex((n) => n.node === node);
-      if (index !== -1) {
-        queuedAudioNodes.splice(index, 1);
-      }
-    },
-    getAndClearAudioChunksForAfterResuming: () => {
-      const chunks = audioChunksForAfterResuming.slice();
-      audioChunksForAfterResuming.length = 0;
-      return chunks;
+    guessNextTimestamp: () => {
+      return !Number.isFinite(mostRecentTimestamp) ? startFromSecond : mostRecentTimestamp;
     },
     getQueuedPeriod: () => {
       let until = -Infinity;
@@ -353,10 +248,6 @@ var makeAudioIterator = ({
         until = Math.max(until, node.timestamp + node.buffer.duration);
         from = Math.min(from, node.timestamp);
       }
-      for (const chunk of audioChunksForAfterResuming) {
-        until = Math.max(until, chunk.timestamp + chunk.buffer.duration);
-        from = Math.min(from, chunk.timestamp);
-      }
       if (!Number.isFinite(from) || !Number.isFinite(until)) {
         return null;
       }
@@ -364,12 +255,7 @@ var makeAudioIterator = ({
         from,
         until
       };
-    },
-    tryToSatisfySeek,
-    bufferAsFarAsPossible,
-    addChunkForAfterResuming,
-    moveQueuedChunksToPauseQueue,
-    getNumberOfChunksAfterResuming
+    }
   };
 };
 var isAlreadyQueued = (time, queuedPeriod) => {
@@ -379,224 +265,183 @@ var isAlreadyQueued = (time, queuedPeriod) => {
   return time >= queuedPeriod.from && time < queuedPeriod.until;
 };
 
-// src/make-iterator-with-priming.ts
-var AUDIO_PRIMING_SECONDS = 0.5;
-var PREDECODE_AHEAD_SECONDS = 2;
-function makePredecodingIterator(inner) {
-  const buffer = [];
-  let consumerEndTime = 0;
-  let innerDone = false;
-  let returned = false;
-  let fetching = false;
-  let waiter = null;
-  const prefetch = () => {
-    if (fetching || returned || innerDone) {
-      return;
-    }
-    const lastBuffered = buffer.length > 0 ? buffer[buffer.length - 1] : null;
-    const bufferedEndTime = lastBuffered ? lastBuffered.timestamp + lastBuffered.duration : consumerEndTime;
-    if (bufferedEndTime >= consumerEndTime + PREDECODE_AHEAD_SECONDS) {
-      return;
-    }
-    fetching = true;
-    inner.next().then((result) => {
-      fetching = false;
-      if (returned) {
-        return;
-      }
-      if (result.done) {
-        innerDone = true;
-        if (waiter) {
-          const w = waiter;
-          waiter = null;
-          w({ value: undefined, done: true });
-        }
-        return;
-      }
-      if (waiter) {
-        const w = waiter;
-        waiter = null;
-        const buf = result.value;
-        consumerEndTime = buf.timestamp + buf.duration;
-        w({ value: buf, done: false });
-        prefetch();
-        return;
-      }
-      buffer.push(result.value);
-      prefetch();
-    }, () => {
-      fetching = false;
-      innerDone = true;
-      if (waiter) {
-        const w = waiter;
-        waiter = null;
-        w({ value: undefined, done: true });
-      }
-    });
-  };
-  prefetch();
-  const _return = () => {
-    returned = true;
-    buffer.length = 0;
-    if (waiter) {
-      const w = waiter;
-      waiter = null;
-      w({ value: undefined, done: true });
-    }
-    inner.return(undefined);
-    return Promise.resolve({ value: undefined, done: true });
-  };
-  const iterator = {
-    next() {
-      if (buffer.length > 0) {
-        const buf = buffer.shift();
-        consumerEndTime = buf.timestamp + buf.duration;
-        prefetch();
-        return Promise.resolve({ value: buf, done: false });
-      }
-      if (innerDone) {
-        return Promise.resolve({
-          value: undefined,
-          done: true
-        });
-      }
-      return new Promise((resolve) => {
-        waiter = resolve;
-        prefetch();
-      });
-    },
-    return: _return,
-    throw(e) {
-      returned = true;
-      buffer.length = 0;
-      return inner.throw(e);
-    },
-    [Symbol.asyncIterator]() {
-      return iterator;
-    }
-  };
-  return iterator;
-}
-async function* makeIteratorWithPrimingInner(audioSink, timeToSeek, maximumTimestamp) {
-  const primingStart = Math.max(0, timeToSeek - AUDIO_PRIMING_SECONDS);
-  const iterator = audioSink.buffers(primingStart, maximumTimestamp);
-  for await (const buffer of iterator) {
-    if (buffer.timestamp + buffer.duration <= timeToSeek) {
-      continue;
-    }
-    yield buffer;
-  }
-}
-var makeIteratorWithPriming = ({
-  audioSink,
-  timeToSeek,
-  maximumTimestamp
+// src/audio/get-scheduled-time.ts
+var getScheduledTime = ({
+  mediaTimestamp,
+  targetTime,
+  currentTime,
+  sequenceStartTime
 }) => {
-  return makePredecodingIterator(makeIteratorWithPrimingInner(audioSink, timeToSeek, maximumTimestamp));
+  const needsTrimStart = mediaTimestamp < sequenceStartTime;
+  const offsetBecauseOfTrim = needsTrimStart ? sequenceStartTime - mediaTimestamp : 0;
+  const offsetBecauseOfTooLate = targetTime < 0 ? -targetTime : 0;
+  const offset = offsetBecauseOfTrim + offsetBecauseOfTooLate;
+  const scheduledTime = targetTime + currentTime + offset;
+  return scheduledTime;
 };
-
-// src/prewarm-iterator-for-looping.ts
-var makePrewarmedVideoIteratorCache = (videoSink) => {
-  const prewarmedVideoIterators = new Map;
-  const prewarmIteratorForLooping = ({ timeToSeek }) => {
-    if (!prewarmedVideoIterators.has(timeToSeek)) {
-      prewarmedVideoIterators.set(timeToSeek, videoSink.canvases(timeToSeek));
-    }
-  };
-  const makeIteratorOrUsePrewarmed = (timeToSeek) => {
-    const prewarmedIterator = prewarmedVideoIterators.get(timeToSeek);
-    if (prewarmedIterator) {
-      prewarmedVideoIterators.delete(timeToSeek);
-      return prewarmedIterator;
-    }
-    const iterator = videoSink.canvases(timeToSeek);
-    return iterator;
-  };
-  const destroy = () => {
-    for (const iterator of prewarmedVideoIterators.values()) {
-      iterator.return();
-    }
-    prewarmedVideoIterators.clear();
-  };
-  return {
-    prewarmIteratorForLooping,
-    makeIteratorOrUsePrewarmed,
-    destroy
-  };
+var getDurationOfNode = ({
+  bufferDuration,
+  loopSegmentMediaEndTimestamp,
+  offset,
+  originalUnloopedMediaTimestamp
+}) => {
+  const originalUnloopedMediaEndTime = originalUnloopedMediaTimestamp + bufferDuration;
+  const needsTrimEnd = originalUnloopedMediaEndTime > loopSegmentMediaEndTimestamp;
+  const durationMinusOffset = bufferDuration - offset;
+  const duration = needsTrimEnd ? durationMinusOffset - Math.max(0, originalUnloopedMediaEndTime - loopSegmentMediaEndTimestamp) : durationMinusOffset;
+  return duration;
 };
-var makeKey = (timeToSeek, maximumTimestamp) => {
-  return `${timeToSeek}-${maximumTimestamp}`;
+var getOffset = ({
+  mediaTimestamp,
+  targetTime,
+  sequenceStartTime
+}) => {
+  const needsTrimStart = mediaTimestamp < sequenceStartTime;
+  const offsetBecauseOfTrim = needsTrimStart ? sequenceStartTime - mediaTimestamp : 0;
+  const offsetBecauseOfTooLate = targetTime < 0 ? -targetTime : 0;
+  const offset = offsetBecauseOfTrim + offsetBecauseOfTooLate;
+  return offset;
 };
-var makePrewarmedAudioIteratorCache = (audioSink) => {
-  const prewarmedAudioIterators = new Map;
-  const prewarmIteratorForLooping = ({
-    timeToSeek,
-    maximumTimestamp
-  }) => {
-    if (!prewarmedAudioIterators.has(makeKey(timeToSeek, maximumTimestamp))) {
-      prewarmedAudioIterators.set(makeKey(timeToSeek, maximumTimestamp), makeIteratorWithPriming({ audioSink, timeToSeek, maximumTimestamp }));
+
+// src/audio/sort-by-priority.ts
+class StaleWaiterError extends Error {
+  constructor() {
+    super("Waiter became stale before it got its turn");
+    this.name = "StaleWaiterError";
+  }
+}
+var CONCURRENCY = 1;
+var waiters = [];
+var running = 0;
+var processNext = () => {
+  if (running >= CONCURRENCY) {
+    return;
+  }
+  const staleWaiters = [];
+  for (let i = waiters.length - 1;i >= 0; i--) {
+    if (waiters[i].getPriority() === null) {
+      const [stale] = waiters.splice(i, 1);
+      staleWaiters.push(stale);
     }
-  };
-  const makeIteratorOrUsePrewarmed = (timeToSeek, maximumTimestamp) => {
-    const prewarmedIterator = prewarmedAudioIterators.get(makeKey(timeToSeek, maximumTimestamp));
-    if (prewarmedIterator) {
-      prewarmedAudioIterators.delete(makeKey(timeToSeek, maximumTimestamp));
-      return prewarmedIterator;
+  }
+  for (const stale of staleWaiters) {
+    stale.onError(new StaleWaiterError);
+  }
+  if (waiters.length === 0) {
+    return;
+  }
+  let bestIndex = 0;
+  let bestPriority = waiters[0].getPriority();
+  if (bestPriority === null) {
+    throw new Error("Stale waiter should have been removed");
+  }
+  for (let i = 1;i < waiters.length; i++) {
+    const priority = waiters[i].getPriority();
+    if (priority === null) {
+      throw new Error("Stale waiter should have been removed");
     }
-    const iterator = makeIteratorWithPriming({
-      audioSink,
-      timeToSeek,
-      maximumTimestamp
-    });
-    return iterator;
-  };
-  const destroy = () => {
-    for (const iterator of prewarmedAudioIterators.values()) {
-      iterator.return();
+    if (priority < bestPriority) {
+      bestPriority = priority;
+      bestIndex = i;
     }
-    prewarmedAudioIterators.clear();
-  };
-  return {
-    prewarmIteratorForLooping,
-    makeIteratorOrUsePrewarmed,
-    destroy
-  };
+  }
+  if (bestPriority > 2) {
+    return;
+  }
+  const [next] = waiters.splice(bestIndex, 1);
+  running++;
+  next.fn().then((value) => {
+    running--;
+    next.onDone(value, processNext);
+  }, (err) => {
+    running--;
+    next.onError(err);
+  });
+};
+var waitForTurn = ({
+  getPriority,
+  fn,
+  onDone,
+  onError
+}) => {
+  waiters.push({
+    getPriority,
+    fn,
+    onDone,
+    onError
+  });
+  processNext();
 };
 
 // src/audio-iterator-manager.ts
-var MAX_BUFFER_AHEAD_SECONDS = 2;
 var audioIteratorManager = ({
   audioTrack,
   delayPlaybackHandleIfNotPremounting,
   sharedAudioContext,
-  getIsLooping,
-  getEndTime,
+  getSequenceEndTimestamp,
+  getSequenceDurationInSeconds,
+  getMediaEndTimestamp,
   getStartTime,
   initialMuted,
-  drawDebugOverlay
+  drawDebugOverlay,
+  initialPlaybackRate,
+  initialTrimBefore,
+  initialTrimAfter,
+  initialSequenceOffset,
+  initialSequenceDurationInFrames,
+  initialLoop,
+  initialFps
 }) => {
   let muted = initialMuted;
   let currentVolume = 1;
+  let currentSeek = {
+    time: -1,
+    playbackRate: initialPlaybackRate,
+    trimBefore: initialTrimBefore,
+    trimAfter: initialTrimAfter,
+    sequenceOffset: initialSequenceOffset,
+    sequenceDurationInFrames: initialSequenceDurationInFrames,
+    loop: initialLoop,
+    fps: initialFps
+  };
   const gainNode = sharedAudioContext.audioContext.createGain();
-  gainNode.connect(sharedAudioContext.audioContext.destination);
+  gainNode.connect(sharedAudioContext.gainNode);
   const audioSink = new AudioBufferSink(audioTrack);
-  const prewarmedAudioIteratorCache = makePrewarmedAudioIteratorCache(audioSink);
   let audioBufferIterator = null;
   let audioIteratorsCreated = 0;
+  let totalAudioScheduledInSeconds = 0;
   let currentDelayHandle = null;
+  const pendingScheduleWaiters = [];
+  const notifyNodeScheduled = () => {
+    for (let i = pendingScheduleWaiters.length - 1;i >= 0; i--) {
+      const waiter = pendingScheduleWaiters[i];
+      waiter.remaining--;
+      if (waiter.remaining <= 0) {
+        waiter.resolve();
+        pendingScheduleWaiters.splice(i, 1);
+      }
+    }
+  };
+  const waitForNScheduledNodes = (n) => {
+    if (n <= 0) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      pendingScheduleWaiters.push({ remaining: n, resolve });
+    });
+  };
   const scheduleAudioChunk = ({
     buffer,
     mediaTimestamp,
+    originalUnloopedMediaTimestamp,
     playbackRate,
     scheduleAudioNode,
-    debugAudioScheduling
+    logLevel,
+    currentTime
   }) => {
     if (!audioBufferIterator) {
       throw new Error("Audio buffer iterator not found");
     }
-    if (sharedAudioContext.audioContext.state !== "running") {
-      throw new Error("Tried to schedule node while audio context is not running");
-    }
     if (muted) {
       return;
     }
@@ -604,252 +449,247 @@ var audioIteratorManager = ({
     node.buffer = buffer;
     node.playbackRate.value = playbackRate;
     node.connect(gainNode);
-    const started = scheduleAudioNode(node, mediaTimestamp);
+    const started = scheduleAudioNode(node, mediaTimestamp, originalUnloopedMediaTimestamp, currentTime);
     if (started.type === "not-started") {
-      if (debugAudioScheduling) {
-        Internals4.Log.info({ logLevel: "trace", tag: "audio-scheduling" }, "not started, disconnected: %s %s", mediaTimestamp.toFixed(3), buffer.duration.toFixed(3));
-      }
+      Internals2.Log.verbose({ logLevel, tag: "audio-scheduling" }, "not started, disconnected: %s %s", mediaTimestamp.toFixed(3), buffer.duration.toFixed(3));
       node.disconnect();
       return;
     }
-    const iterator = audioBufferIterator;
-    iterator.addQueuedAudioNode({
+    audioBufferIterator.addQueuedAudioNode({
       node,
       timestamp: mediaTimestamp,
       buffer,
       scheduledTime: started.scheduledTime,
-      playbackRate,
       scheduledAtAnchor: sharedAudioContext.audioSyncAnchor.value
     });
-    node.onended = () => {
-      setTimeout(() => {
-        iterator.removeQueuedAudioNode(node);
-      }, 30);
-    };
-  };
-  const resumeScheduledAudioChunks = ({
-    playbackRate,
-    scheduleAudioNode,
-    debugAudioScheduling
-  }) => {
-    if (muted) {
-      return;
-    }
-    if (!audioBufferIterator) {
-      return;
-    }
-    for (const chunk of audioBufferIterator.getAndClearAudioChunksForAfterResuming()) {
-      scheduleAudioChunk({
-        buffer: chunk.buffer,
-        mediaTimestamp: chunk.timestamp,
-        playbackRate,
-        scheduleAudioNode,
-        debugAudioScheduling
-      });
-    }
   };
   const onAudioChunk = ({
-    getIsPlaying,
     buffer,
     playbackRate,
     scheduleAudioNode,
-    debugAudioScheduling
+    logLevel,
+    currentTime
   }) => {
     if (muted) {
       return;
     }
     const startTime = getStartTime();
-    const endTime = getEndTime();
-    if (buffer.timestamp + buffer.duration <= startTime) {
+    const sequenceEndTime = getSequenceEndTimestamp();
+    if (buffer.timestamp + buffer.buffer.duration <= startTime) {
       return;
     }
-    if (buffer.timestamp >= endTime) {
+    if (buffer.timestamp >= sequenceEndTime) {
       return;
     }
-    if (getIsPlaying() && sharedAudioContext.audioContext.state === "running" && (sharedAudioContext.audioContext.getOutputTimestamp().contextTime ?? 0) > 0) {
-      resumeScheduledAudioChunks({
-        playbackRate,
-        scheduleAudioNode,
-        debugAudioScheduling
-      });
-      scheduleAudioChunk({
-        buffer: buffer.buffer,
-        mediaTimestamp: buffer.timestamp,
-        playbackRate,
-        scheduleAudioNode,
-        debugAudioScheduling
-      });
-    } else {
-      if (!audioBufferIterator) {
-        throw new Error("Audio buffer iterator not found");
-      }
-      if (debugAudioScheduling) {
-        Internals4.Log.info({ logLevel: "trace", tag: "audio-scheduling" }, "not ready, added to queue: %s %s", buffer.timestamp.toFixed(3), buffer.duration.toFixed(3));
-      }
-      audioBufferIterator.addChunkForAfterResuming(buffer.buffer, buffer.timestamp);
-    }
+    const scheduledStart = Math.max(buffer.timestamp, startTime);
+    const scheduledEnd = Math.min(buffer.timestamp + buffer.buffer.duration, sequenceEndTime);
+    totalAudioScheduledInSeconds += Math.max(0, scheduledEnd - scheduledStart);
+    scheduleAudioChunk({
+      buffer: buffer.buffer.buffer,
+      mediaTimestamp: buffer.timestamp,
+      playbackRate,
+      scheduleAudioNode,
+      logLevel,
+      originalUnloopedMediaTimestamp: buffer.buffer.timestamp,
+      currentTime
+    });
     drawDebugOverlay();
   };
-  const startAudioIterator = async ({
+  const proceedScheduling = ({
+    iterator,
     nonce,
+    getTargetTime,
     playbackRate,
-    startFromSecond,
-    getIsPlaying,
     scheduleAudioNode,
-    debugAudioScheduling
+    onScheduled,
+    onDestroyed,
+    onDone,
+    logLevel,
+    currentTime,
+    getAudioContextCurrentTimeMockedInTest
   }) => {
-    let __stack = [];
-    try {
-      if (muted) {
-        return;
-      }
-      audioBufferIterator?.destroy(sharedAudioContext);
-      const delayHandle = __using(__stack, delayPlaybackHandleIfNotPremounting(), 0);
-      currentDelayHandle = delayHandle;
-      const iterator = makeAudioIterator({
-        startFromSecond,
-        maximumTimestamp: getEndTime(),
-        cache: prewarmedAudioIteratorCache,
-        debugAudioScheduling
-      });
-      audioIteratorsCreated++;
-      audioBufferIterator = iterator;
-      try {
-        for (let i = 0;i < 6; i++) {
-          const result = await iterator.getNext();
-          if (iterator.isDestroyed()) {
-            return;
-          }
-          if (nonce.isStale()) {
-            return;
-          }
-          if (!result.value) {
-            return;
-          }
-          onAudioChunk({
-            getIsPlaying,
-            buffer: result.value,
-            playbackRate,
-            scheduleAudioNode,
-            debugAudioScheduling
-          });
+    waitForTurn({
+      getPriority: () => {
+        if (iterator.isDestroyed()) {
+          return null;
         }
-        await iterator.bufferAsFarAsPossible((buffer) => {
-          if (!nonce.isStale()) {
-            onAudioChunk({
-              getIsPlaying,
-              buffer,
-              playbackRate,
-              scheduleAudioNode,
-              debugAudioScheduling
-            });
-          }
-        }, Math.min(startFromSecond + MAX_BUFFER_AHEAD_SECONDS, getEndTime()));
-      } catch (e) {
+        const guessedNextTimestamp = iterator.guessNextTimestamp();
+        const targetTime = getTargetTime(guessedNextTimestamp, currentTime);
+        if (targetTime === null) {
+          return null;
+        }
+        const scheduledTime = getScheduledTime({
+          mediaTimestamp: guessedNextTimestamp,
+          targetTime,
+          currentTime,
+          sequenceStartTime: getStartTime()
+        });
+        return scheduledTime - getAudioContextCurrentTimeMockedInTest();
+      },
+      fn: () => iterator.getNextFn(),
+      onDone: (result, next) => {
+        if (iterator.isDestroyed()) {
+          next();
+          onDestroyed();
+          return;
+        }
+        if (!result.value) {
+          next();
+          return;
+        }
+        onScheduled(result.value.timestamp);
+        notifyNodeScheduled();
+        onAudioChunk({
+          buffer: result.value,
+          playbackRate,
+          scheduleAudioNode,
+          logLevel,
+          currentTime
+        });
+        proceedScheduling({
+          iterator,
+          nonce,
+          getTargetTime,
+          playbackRate,
+          scheduleAudioNode,
+          onScheduled,
+          onDestroyed,
+          onDone,
+          logLevel,
+          currentTime,
+          getAudioContextCurrentTimeMockedInTest
+        });
+        next();
+      },
+      onError: (e) => {
         if (e instanceof InputDisposedError) {
           return;
         }
-        throw e;
-      }
-    } catch (_catch) {
-      var _err = _catch, _hasErr = 1;
-    } finally {
-      __callDispose(__stack, _err, _hasErr);
-    }
+        if (e instanceof StaleWaiterError) {
+          return;
+        }
+        throw e;
+      }
+    });
   };
-  const pausePlayback = () => {
-    if (!audioBufferIterator) {
+  const startAudioIterator = ({
+    nonce,
+    playbackRate,
+    startFromSecond,
+    scheduleAudioNode,
+    getTargetTime,
+    logLevel,
+    loop,
+    unscheduleAudioNode,
+    getAudioContextCurrentTimeMockedInTest
+  }) => {
+    if (muted) {
       return;
     }
-    audioBufferIterator.moveQueuedChunksToPauseQueue();
+    const maximumTimestamp = getMediaEndTimestamp();
+    if (startFromSecond >= maximumTimestamp) {
+      return;
+    }
+    audioBufferIterator?.destroy();
+    const delayHandle = delayPlaybackHandleIfNotPremounting();
+    currentDelayHandle = delayHandle;
+    const iterator = makeAudioIterator({
+      startFromSecond,
+      maximumTimestamp,
+      audioSink,
+      logLevel,
+      loop,
+      playbackRate,
+      sequenceDurationInSeconds: getSequenceDurationInSeconds(),
+      unscheduleAudioNode
+    });
+    audioIteratorsCreated++;
+    audioBufferIterator = iterator;
+    proceedScheduling({
+      iterator,
+      nonce,
+      getTargetTime,
+      playbackRate,
+      scheduleAudioNode,
+      onScheduled: () => {
+        delayHandle.unblock();
+      },
+      onDestroyed: () => {
+        delayHandle.unblock();
+      },
+      onDone: () => {
+        delayHandle.unblock();
+      },
+      logLevel,
+      currentTime: sharedAudioContext.audioContext.currentTime,
+      getAudioContextCurrentTimeMockedInTest
+    });
   };
-  const seek = async ({
+  const seek = ({
     newTime,
     nonce,
     playbackRate,
-    getIsPlaying,
     scheduleAudioNode,
-    debugAudioScheduling
+    getTargetTime,
+    logLevel,
+    loop,
+    trimBefore,
+    trimAfter,
+    sequenceOffset,
+    sequenceDurationInFrames,
+    fps,
+    getAudioContextCurrentTimeMockedInTest
   }) => {
-    if (muted) {
+    if (currentSeek.time === newTime && currentSeek.playbackRate === playbackRate && currentSeek.trimBefore === trimBefore && currentSeek.trimAfter === trimAfter && currentSeek.sequenceOffset === sequenceOffset && currentSeek.sequenceDurationInFrames === sequenceDurationInFrames && currentSeek.loop === loop && currentSeek.fps === fps) {
       return;
     }
-    if (getIsLooping()) {
-      if (getEndTime() - newTime < 1) {
-        prewarmedAudioIteratorCache.prewarmIteratorForLooping({
-          timeToSeek: getStartTime(),
-          maximumTimestamp: getEndTime()
-        });
-      }
-    }
-    if (!audioBufferIterator) {
-      await startAudioIterator({
-        nonce,
-        playbackRate,
-        startFromSecond: newTime,
-        getIsPlaying,
-        scheduleAudioNode,
-        debugAudioScheduling
-      });
+    currentSeek = {
+      time: newTime,
+      playbackRate,
+      trimBefore,
+      trimAfter,
+      sequenceOffset,
+      sequenceDurationInFrames,
+      loop,
+      fps
+    };
+    if (muted) {
       return;
     }
-    const queuedPeriod = audioBufferIterator.getQueuedPeriod();
-    const queuedPeriodMinusLatency = queuedPeriod ? {
-      from: queuedPeriod.from - ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT - sharedAudioContext.audioContext.baseLatency - sharedAudioContext.audioContext.outputLatency,
-      until: queuedPeriod.until
-    } : null;
-    const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, queuedPeriodMinusLatency);
-    if (!currentTimeIsAlreadyQueued) {
-      const audioSatisfyResult = await audioBufferIterator.tryToSatisfySeek(newTime, (buffer) => {
-        if (!nonce.isStale()) {
-          onAudioChunk({
-            getIsPlaying,
-            buffer,
-            playbackRate,
-            scheduleAudioNode,
-            debugAudioScheduling
-          });
-        }
-      });
-      if (nonce.isStale()) {
-        return;
-      }
-      if (audioSatisfyResult.type === "ended") {
+    if (audioBufferIterator && !audioBufferIterator.isDestroyed()) {
+      const queuedPeriod = audioBufferIterator.getQueuedPeriod();
+      const queuedPeriodMinusLatency = queuedPeriod ? {
+        from: queuedPeriod.from - ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT - sharedAudioContext.audioContext.baseLatency - sharedAudioContext.audioContext.outputLatency,
+        until: queuedPeriod.until
+      } : null;
+      const currentTimeIsAlreadyQueued = isAlreadyQueued(newTime, queuedPeriodMinusLatency);
+      if (currentTimeIsAlreadyQueued) {
+        processNext();
         return;
       }
-      if (audioSatisfyResult.type === "not-satisfied") {
-        await startAudioIterator({
-          nonce,
-          playbackRate,
-          startFromSecond: newTime,
-          getIsPlaying,
-          scheduleAudioNode,
-          debugAudioScheduling
-        });
+      const currentIteratorTimestamp = audioBufferIterator.guessNextTimestamp();
+      if (currentIteratorTimestamp < newTime && Math.abs(currentIteratorTimestamp - newTime) < 1) {
+        processNext();
         return;
       }
-      if (audioSatisfyResult.type === "satisfied") {}
     }
-    await audioBufferIterator.bufferAsFarAsPossible((buffer) => {
-      if (!nonce.isStale()) {
-        onAudioChunk({
-          getIsPlaying,
-          buffer,
-          playbackRate,
-          scheduleAudioNode,
-          debugAudioScheduling
-        });
-      }
-    }, Math.min(newTime + MAX_BUFFER_AHEAD_SECONDS, getEndTime()));
+    startAudioIterator({
+      nonce,
+      playbackRate,
+      startFromSecond: newTime,
+      scheduleAudioNode,
+      getTargetTime,
+      logLevel,
+      loop,
+      unscheduleAudioNode: sharedAudioContext.unscheduleAudioNode,
+      getAudioContextCurrentTimeMockedInTest
+    });
   };
   return {
     startAudioIterator,
-    resumeScheduledAudioChunks,
-    pausePlayback,
     getAudioBufferIterator: () => audioBufferIterator,
     destroyIterator: () => {
-      prewarmedAudioIteratorCache.destroy();
-      audioBufferIterator?.destroy(sharedAudioContext);
+      audioBufferIterator?.destroy();
       audioBufferIterator = null;
       if (currentDelayHandle) {
         currentDelayHandle.unblock();
@@ -858,6 +698,7 @@ var audioIteratorManager = ({
     },
     seek,
     getAudioIteratorsCreated: () => audioIteratorsCreated,
+    getTotalAudioScheduledInSeconds: () => totalAudioScheduledInSeconds,
     setMuted: (newMuted) => {
       muted = newMuted;
       gainNode.gain.value = muted ? 0 : currentVolume;
@@ -866,7 +707,8 @@ var audioIteratorManager = ({
       currentVolume = Math.max(0, volume);
       gainNode.gain.value = muted ? 0 : currentVolume;
     },
-    scheduleAudioChunk
+    scheduleAudioChunk,
+    waitForNScheduledNodes
   };
 };
 
@@ -886,6 +728,7 @@ var drawPreviewOverlay = ({
     "Debug overlay",
     `Video iterators created: ${videoIteratorManager?.getVideoIteratorsCreated()}`,
     `Audio iterators created: ${audioIteratorManager2?.getAudioIteratorsCreated()}`,
+    `Audio scheduled: ${(audioIteratorManager2?.getTotalAudioScheduledInSeconds() ?? 0).toFixed(3)}s`,
     `Frames rendered: ${videoIteratorManager?.getFramesRendered()}`,
     `Audio context state: ${audioContextState}`,
     audioTime ? `Audio time: ${((audioTime - anchorValue) * playbackRate).toFixed(3)}s` : null
@@ -943,55 +786,149 @@ var makeNonceManager = () => {
 
 // src/video-iterator-manager.ts
 import { CanvasSink } from "mediabunny";
-import { Internals as Internals5 } from "remotion";
+import { Internals as Internals3 } from "remotion";
+
+// src/canvas-ahead-of-time.ts
+var canvasesAheadOfTime = (videoSink, startTimestamp) => {
+  const iterator = videoSink.canvases(startTimestamp);
+  let inFlight = iterator.next();
+  let resolved = null;
+  const trackResolution = () => {
+    const captured = inFlight;
+    captured.then((result) => {
+      if (captured === inFlight) {
+        resolved = result;
+      }
+    }, () => {
+      return;
+    });
+  };
+  trackResolution();
+  const advance = () => {
+    inFlight = iterator.next();
+    resolved = null;
+    trackResolution();
+  };
+  const next = () => {
+    if (resolved) {
+      if (resolved.done) {
+        return { type: "ready", frame: null };
+      }
+      const frame = resolved.value;
+      advance();
+      return { type: "ready", frame };
+    }
+    const captured = inFlight;
+    return {
+      type: "pending",
+      wait: async () => {
+        const result = await captured;
+        if (captured === inFlight && !result.done) {
+          advance();
+        }
+        return result.done ? null : result.value;
+      }
+    };
+  };
+  const closeFrame = (frame) => {
+    frame.close?.();
+  };
+  const closeIterator = async () => {
+    if (resolved) {
+      if (!resolved.done) {
+        closeFrame(resolved.value);
+      }
+    } else {
+      const captured = inFlight;
+      captured.then((result) => {
+        if (!result.done) {
+          closeFrame(result.value);
+        }
+      }, () => {
+        return;
+      });
+    }
+    await iterator.return();
+  };
+  return { next, closeIterator };
+};
+
+// src/prewarm-iterator-for-looping.ts
+var makePrewarmedVideoIteratorCache = (videoSink) => {
+  const prewarmedVideoIterators = new Map;
+  const prewarmIteratorForLooping = ({ timeToSeek }) => {
+    if (!prewarmedVideoIterators.has(timeToSeek)) {
+      prewarmedVideoIterators.set(timeToSeek, canvasesAheadOfTime(videoSink, timeToSeek));
+    }
+  };
+  const makeIteratorOrUsePrewarmed = (timeToSeek) => {
+    const prewarmedIterator = prewarmedVideoIterators.get(timeToSeek);
+    if (prewarmedIterator) {
+      prewarmedVideoIterators.delete(timeToSeek);
+      return prewarmedIterator;
+    }
+    return canvasesAheadOfTime(videoSink, timeToSeek);
+  };
+  const destroy = () => {
+    for (const iterator of prewarmedVideoIterators.values()) {
+      iterator.closeIterator();
+    }
+    prewarmedVideoIterators.clear();
+  };
+  return {
+    prewarmIteratorForLooping,
+    makeIteratorOrUsePrewarmed,
+    destroy
+  };
+};
+
+// src/helpers/round-to-4-digits.ts
+var roundTo4Digits = (timestamp) => {
+  return Math.round(timestamp * 1000) / 1000;
+};
 
 // src/video/video-preview-iterator.ts
 var createVideoIterator = async (timeToSeek, cache) => {
   let destroyed = false;
   const iterator = cache.makeIteratorOrUsePrewarmed(timeToSeek);
   let iteratorEnded = false;
-  const initialFrame = (await iterator.next())?.value ?? null;
+  const firstAwait = iterator.next();
+  const initialFrame = firstAwait && firstAwait.type === "ready" ? firstAwait.frame : await firstAwait.wait();
   let lastReturnedFrame = initialFrame;
-  const getNextOrNullIfNotAvailable = async () => {
+  const getNextOrNullIfNotAvailable = () => {
     const next = iterator.next();
-    const result = await Promise.race([
-      next,
-      new Promise((resolve) => {
-        Promise.resolve().then(() => resolve());
-      })
-    ]);
-    if (!result) {
+    if (next.type === "pending") {
       return {
         type: "need-to-wait-for-it",
         waitPromise: async () => {
-          const res = await next;
-          if (res.value) {
-            lastReturnedFrame = res.value;
+          const res = await next.wait();
+          if (res) {
+            lastReturnedFrame = res;
           } else {
             iteratorEnded = true;
           }
-          return res.value;
+          return res;
         }
       };
     }
-    if (result.value) {
-      lastReturnedFrame = result.value;
+    if (next.frame) {
+      lastReturnedFrame = next.frame;
     } else {
       iteratorEnded = true;
     }
     return {
       type: "got-frame-or-end",
-      frame: result.value ?? null
+      frame: next.frame ?? null
     };
   };
   const destroy = () => {
     destroyed = true;
     lastReturnedFrame = null;
-    iterator.return().catch(() => {
+    iterator.closeIterator().catch(() => {
       return;
     });
   };
-  const tryToSatisfySeek = async (time) => {
+  const tryToSatisfySeek = (time) => {
     if (lastReturnedFrame) {
       const frameTimestamp = roundTo4Digits(lastReturnedFrame.timestamp);
       if (roundTo4Digits(time) < frameTimestamp) {
@@ -1030,7 +967,7 @@ var createVideoIterator = async (timeToSeek, cache) => {
       };
     }
     while (true) {
-      const frame = await getNextOrNullIfNotAvailable();
+      const frame = getNextOrNullIfNotAvailable();
       if (frame.type === "need-to-wait-for-it") {
         return {
           type: "not-satisfied",
@@ -1084,7 +1021,7 @@ var videoIteratorManager = ({
   logLevel,
   getOnVideoFrameCallback,
   videoTrack,
-  getEndTime,
+  getLoopSegmentMediaEndTimestamp,
   getStartTime,
   getIsLooping
 }) => {
@@ -1115,7 +1052,7 @@ var videoIteratorManager = ({
     if (callback) {
       callback(frame.canvas);
     }
-    Internals5.Log.trace({ logLevel, tag: "@remotion/media" }, `[MediaPlayer] Drew frame ${frame.timestamp.toFixed(3)}s`);
+    Internals3.Log.trace({ logLevel, tag: "@remotion/media" }, `[MediaPlayer] Drew frame ${frame.timestamp.toFixed(3)}s`);
   };
   const startVideoIterator = async (timeToSeek, nonce) => {
     let __stack = [];
@@ -1150,13 +1087,13 @@ var videoIteratorManager = ({
       return;
     }
     if (getIsLooping()) {
-      if (getEndTime() - newTime < 1) {
+      if (getLoopSegmentMediaEndTimestamp() - newTime < 1) {
         prewarmedVideoIteratorCache.prewarmIteratorForLooping({
           timeToSeek: getStartTime()
         });
       }
     }
-    const videoSatisfyResult = await videoFrameIterator.tryToSatisfySeek(newTime);
+    const videoSatisfyResult = videoFrameIterator.tryToSatisfySeek(newTime);
     if (videoSatisfyResult.type === "satisfied") {
       drawFrame(videoSatisfyResult.frame);
       return;
@@ -1190,6 +1127,7 @@ var videoIteratorManager = ({
 
 // src/media-player.ts
 class MediaPlayer {
+  tagType;
   canvas;
   context;
   src;
@@ -1200,16 +1138,15 @@ class MediaPlayer {
   sharedAudioContext;
   audioIteratorManager = null;
   videoIteratorManager = null;
-  sequenceOffset;
   playing = false;
   loop = false;
   fps;
   trimBefore;
   trimAfter;
-  durationInFrames;
+  sequenceDurationInFrames;
+  sequenceOffset;
   totalDuration;
   debugOverlay = false;
-  debugAudioScheduling = false;
   nonceManager;
   onVideoFrameCallback = null;
   initializationPromise = null;
@@ -1230,7 +1167,6 @@ class MediaPlayer {
     audioStreamIndex,
     fps,
     debugOverlay,
-    debugAudioScheduling,
     bufferState,
     isPremounting,
     isPostmounting,
@@ -1238,7 +1174,8 @@ class MediaPlayer {
     onVideoFrameCallback,
     playing,
     sequenceOffset,
-    credentials
+    credentials,
+    tagType
   }) {
     this.canvas = canvas ?? null;
     this.src = src;
@@ -1252,11 +1189,10 @@ class MediaPlayer {
     this.audioStreamIndex = audioStreamIndex ?? 0;
     this.fps = fps;
     this.debugOverlay = debugOverlay;
-    this.debugAudioScheduling = debugAudioScheduling;
     this.bufferState = bufferState;
     this.isPremounting = isPremounting;
     this.isPostmounting = isPostmounting;
-    this.durationInFrames = durationInFrames;
+    this.sequenceDurationInFrames = durationInFrames;
     this.nonceManager = makeNonceManager();
     this.onVideoFrameCallback = onVideoFrameCallback;
     this.playing = playing;
@@ -1267,6 +1203,7 @@ class MediaPlayer {
       } : undefined),
       formats: ALL_FORMATS
     });
+    this.tagType = tagType;
     if (canvas) {
       const context = canvas.getContext("2d", {
         alpha: true,
@@ -1293,8 +1230,14 @@ class MediaPlayer {
   getStartTime() {
     return (this.trimBefore ?? 0) / this.fps;
   }
-  getEndTime() {
-    const mediaEndTime = calculateEndTime({
+  getSequenceEndTimestamp() {
+    return this.sequenceDurationInFrames / this.fps * this.playbackRate + this.getStartTime();
+  }
+  getSequenceDurationInSeconds() {
+    return this.sequenceDurationInFrames / this.fps;
+  }
+  getMediaEndTimestamp() {
+    return calculateEndTime({
       mediaDurationInSeconds: this.totalDuration,
       ifNoMediaDuration: "fail",
       src: this.src,
@@ -1302,11 +1245,9 @@ class MediaPlayer {
       trimBefore: this.trimBefore,
       fps: this.fps
     });
-    if (this.loop) {
-      return mediaEndTime;
-    }
-    const sequenceEndMediaTime = this.durationInFrames / this.fps * this.playbackRate + (this.trimBefore ?? 0) / this.fps;
-    return Math.min(mediaEndTime, sequenceEndMediaTime);
+  }
+  getLoopSegmentMediaEndTimestamp() {
+    return Math.min(this.getMediaEndTimestamp(), this.getSequenceEndTimestamp());
   }
   async _initialize(startTimeUnresolved, initialMuted) {
     let __stack = [];
@@ -1326,7 +1267,7 @@ class MediaPlayer {
           if (isNetworkError(err)) {
             throw error;
           }
-          Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Failed to recognize format for ${this.src}`, error);
+          Internals4.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([
@@ -1342,7 +1283,7 @@ class MediaPlayer {
         if (!videoTrack && !audioTrack) {
           return { type: "no-tracks" };
         }
-        if (videoTrack) {
+        if (videoTrack && this.tagType === "video") {
           const canDecode = await videoTrack.canDecode();
           if (!canDecode) {
             return { type: "cannot-decode" };
@@ -1358,7 +1299,7 @@ class MediaPlayer {
             getOnVideoFrameCallback: () => this.onVideoFrameCallback,
             logLevel: this.logLevel,
             drawDebugOverlay: this.drawDebugOverlay,
-            getEndTime: () => this.getEndTime(),
+            getLoopSegmentMediaEndTimestamp: () => this.getLoopSegmentMediaEndTimestamp(),
             getStartTime: () => this.getStartTime(),
             getIsLooping: () => this.loop
           });
@@ -1379,11 +1320,19 @@ class MediaPlayer {
             audioTrack,
             delayPlaybackHandleIfNotPremounting: this.delayPlaybackHandleIfNotPremounting,
             sharedAudioContext: this.sharedAudioContext,
-            getIsLooping: () => this.loop,
-            getEndTime: () => this.getEndTime(),
+            getMediaEndTimestamp: () => this.getMediaEndTimestamp(),
+            getSequenceEndTimestamp: () => this.getSequenceEndTimestamp(),
             getStartTime: () => this.getStartTime(),
             initialMuted,
-            drawDebugOverlay: this.drawDebugOverlay
+            drawDebugOverlay: this.drawDebugOverlay,
+            initialPlaybackRate: this.playbackRate * this.globalPlaybackRate,
+            getSequenceDurationInSeconds: () => this.getSequenceDurationInSeconds(),
+            initialTrimBefore: this.trimBefore,
+            initialTrimAfter: this.trimAfter,
+            initialSequenceOffset: this.sequenceOffset,
+            initialSequenceDurationInFrames: this.sequenceDurationInFrames,
+            initialLoop: this.loop,
+            initialFps: this.fps
           });
         }
         const nonce = this.nonceManager.createAsyncOperation();
@@ -1393,9 +1342,12 @@ class MediaPlayer {
               nonce,
               playbackRate: this.playbackRate * this.globalPlaybackRate,
               startFromSecond: startTime,
-              getIsPlaying: () => this.playing,
               scheduleAudioNode: this.scheduleAudioNode,
-              debugAudioScheduling: this.debugAudioScheduling
+              getTargetTime: this.getTargetTime,
+              logLevel: this.logLevel,
+              loop: this.loop,
+              unscheduleAudioNode: this.sharedAudioContext.unscheduleAudioNode,
+              getAudioContextCurrentTimeMockedInTest: () => this.sharedAudioContext.audioContext.currentTime
             }) : Promise.resolve(),
             this.videoIteratorManager ? this.videoIteratorManager.startVideoIterator(startTime, nonce) : Promise.resolve()
           ]);
@@ -1403,16 +1355,16 @@ class MediaPlayer {
           if (this.isDisposalError()) {
             return { type: "disposed" };
           }
-          Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to start audio and video iterators", error);
+          Internals4.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)) {
-          Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Network/CORS error for ${this.src}`, err);
+          Internals4.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, `[MediaPlayer] Network/CORS error for ${this.src}`, err);
           return { type: "network-error" };
         }
-        Internals6.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to initialize", error);
+        Internals4.Log.error({ logLevel: this.logLevel, tag: "@remotion/media" }, "[MediaPlayer] Failed to initialize", error);
         throw error;
       }
     } catch (_catch) {
@@ -1438,21 +1390,27 @@ class MediaPlayer {
     if (nonce.isStale()) {
       return;
     }
-    const shouldSeekAudio = this.audioIteratorManager && this.getAudioPlaybackTime(this.sharedAudioContext?.audioContext.currentTime ?? 0) !== newTime;
     try {
       await Promise.all([
         this.videoIteratorManager?.seek({
           newTime,
           nonce
         }),
-        shouldSeekAudio ? this.audioIteratorManager?.seek({
+        this.audioIteratorManager?.seek({
           newTime,
           nonce,
           playbackRate: this.playbackRate * this.globalPlaybackRate,
-          getIsPlaying: () => this.playing,
+          getTargetTime: this.getTargetTime,
+          logLevel: this.logLevel,
+          loop: this.loop,
+          trimBefore: this.trimBefore,
+          trimAfter: this.trimAfter,
+          sequenceOffset: this.sequenceOffset,
+          sequenceDurationInFrames: this.sequenceDurationInFrames,
+          fps: this.fps,
           scheduleAudioNode: this.scheduleAudioNode,
-          debugAudioScheduling: this.debugAudioScheduling
-        }) : null
+          getAudioContextCurrentTimeMockedInTest: () => this.sharedAudioContext.audioContext.currentTime
+        })
       ]);
     } catch (error) {
       if (this.isDisposalError()) {
@@ -1461,17 +1419,7 @@ class MediaPlayer {
       throw error;
     }
   }
-  playAudio() {
-    if (this.audioIteratorManager && this.sharedAudioContext?.audioContext.state === "running" && (this.sharedAudioContext?.audioContext?.getOutputTimestamp().contextTime ?? 0) > 0) {
-      this.audioIteratorManager.resumeScheduledAudioChunks({
-        playbackRate: this.playbackRate * this.globalPlaybackRate,
-        scheduleAudioNode: this.scheduleAudioNode,
-        debugAudioScheduling: this.debugAudioScheduling
-      });
-    }
-  }
   play() {
-    this.playAudio();
     if (this.playing) {
       return;
     }
@@ -1498,7 +1446,6 @@ class MediaPlayer {
       return;
     }
     this.playing = false;
-    this.audioIteratorManager?.pausePlayback();
     this.drawDebugOverlay();
   }
   setMuted(muted) {
@@ -1523,73 +1470,46 @@ class MediaPlayer {
       src: this.src
     });
   }
-  async updateAfterTrimChange(unloopedTimeInSeconds) {
-    if (!this.audioIteratorManager && !this.videoIteratorManager) {
-      return;
-    }
-    const newMediaTime = this.getTrimmedTime(unloopedTimeInSeconds);
-    this.audioIteratorManager?.destroyIterator();
-    if (newMediaTime !== null) {
-      if (!this.playing && this.videoIteratorManager) {
-        await this.seekToWithQueue(newMediaTime);
-      }
-    }
-  }
   async setTrimBefore(trimBefore, unloopedTimeInSeconds) {
     if (this.trimBefore !== trimBefore) {
       this.trimBefore = trimBefore;
-      await this.updateAfterTrimChange(unloopedTimeInSeconds);
+      this.audioIteratorManager?.destroyIterator();
+      await this.seekTo(unloopedTimeInSeconds);
     }
   }
   async setTrimAfter(trimAfter, unloopedTimeInSeconds) {
     if (this.trimAfter !== trimAfter) {
       this.trimAfter = trimAfter;
-      await this.updateAfterTrimChange(unloopedTimeInSeconds);
+      this.audioIteratorManager?.destroyIterator();
+      await this.seekTo(unloopedTimeInSeconds);
     }
   }
   setDebugOverlay(debugOverlay) {
     this.debugOverlay = debugOverlay;
   }
-  setDebugAudioScheduling(debugAudioScheduling) {
-    this.debugAudioScheduling = debugAudioScheduling;
-  }
-  rescheduleAudioChunks() {
-    if (!this.audioIteratorManager) {
-      return;
-    }
-    if (!this.sharedAudioContext) {
-      return;
-    }
-    const iterator = this.audioIteratorManager.getAudioBufferIterator();
-    if (!iterator) {
-      return;
-    }
-    iterator.moveQueuedChunksToPauseQueue();
-    if (this.playing && this.sharedAudioContext.audioContext.state === "running" && (this.sharedAudioContext.audioContext?.getOutputTimestamp().contextTime ?? 0) > 0) {
-      this.audioIteratorManager.resumeScheduledAudioChunks({
-        playbackRate: this.playbackRate * this.globalPlaybackRate,
-        scheduleAudioNode: this.scheduleAudioNode,
-        debugAudioScheduling: this.debugAudioScheduling
-      });
-    }
-  }
   async setPlaybackRate(rate, unloopedTimeInSeconds) {
     const previousRate = this.playbackRate;
     if (previousRate !== rate) {
       this.playbackRate = rate;
-      this.rescheduleAudioChunks();
+      this.audioIteratorManager?.destroyIterator();
       await this.seekTo(unloopedTimeInSeconds);
     }
   }
-  setGlobalPlaybackRate(rate) {
+  async setGlobalPlaybackRate(rate, unloopedTimeInSeconds) {
     const previousRate = this.globalPlaybackRate;
     if (previousRate !== rate) {
       this.globalPlaybackRate = rate;
-      this.rescheduleAudioChunks();
+      this.audioIteratorManager?.destroyIterator();
+      await this.seekTo(unloopedTimeInSeconds);
     }
   }
-  setFps(fps) {
-    this.fps = fps;
+  async setFps(fps, unloopedTimeInSeconds) {
+    const previousFps = this.fps;
+    if (previousFps !== fps) {
+      this.fps = fps;
+      this.audioIteratorManager?.destroyIterator();
+      await this.seekTo(unloopedTimeInSeconds);
+    }
   }
   setIsPremounting(isPremounting) {
     this.isPremounting = isPremounting;
@@ -1597,14 +1517,28 @@ class MediaPlayer {
   setIsPostmounting(isPostmounting) {
     this.isPostmounting = isPostmounting;
   }
-  setLoop(loop) {
-    this.loop = loop;
+  async setLoop(loop, unloopedTimeInSeconds) {
+    const previousLoop = this.loop;
+    if (previousLoop !== loop) {
+      this.loop = loop;
+      this.audioIteratorManager?.destroyIterator();
+      await this.seekTo(unloopedTimeInSeconds);
+    }
   }
-  setSequenceOffset(offset) {
-    this.sequenceOffset = offset;
+  async setSequenceOffset(offset, unloopedTimeInSeconds) {
+    const previousOffset = this.sequenceOffset;
+    if (previousOffset !== offset) {
+      this.sequenceOffset = offset;
+      this.audioIteratorManager?.destroyIterator();
+      await this.seekTo(unloopedTimeInSeconds);
+    }
   }
-  setDurationInFrames(durationInFrames) {
-    this.durationInFrames = durationInFrames;
+  async setSequenceDurationInFrames(sequenceDurationInFrames, unloopedTimeInSeconds) {
+    const previousDuration = this.sequenceDurationInFrames;
+    if (previousDuration !== sequenceDurationInFrames) {
+      this.sequenceDurationInFrames = sequenceDurationInFrames;
+      await this.seekTo(unloopedTimeInSeconds);
+    }
   }
   async dispose() {
     if (this.initializationPromise) {
@@ -1617,41 +1551,59 @@ class MediaPlayer {
     this.audioIteratorManager?.destroyIterator();
     this.input.dispose();
   }
-  scheduleAudioNode = (node, mediaTimestamp) => {
+  getTargetTime = (mediaTimestamp, currentTime) => {
     if (!this.sharedAudioContext) {
       throw new Error("Shared audio context not found");
     }
-    const { audioContext } = this.sharedAudioContext;
-    const { currentTime } = audioContext;
     const globalTime = (currentTime - this.sharedAudioContext.audioSyncAnchor.value) * this.globalPlaybackRate;
     const timeInSeconds = globalTime - this.sequenceOffset;
     const localTime = this.getTrimmedTime(timeInSeconds);
     if (localTime === null) {
-      return { type: "not-started" };
+      return null;
     }
     const targetTime = (mediaTimestamp - localTime) / (this.playbackRate * this.globalPlaybackRate);
+    return targetTime;
+  };
+  scheduleAudioNode = (node, mediaTimestamp, originalUnloopedMediaTimestamp, currentTime) => {
+    if (!this.sharedAudioContext) {
+      throw new Error("Shared audio context not found");
+    }
+    const targetTime = this.getTargetTime(mediaTimestamp, currentTime);
+    if (targetTime === null) {
+      return {
+        type: "not-started",
+        reason: "no target for" + mediaTimestamp.toFixed(3) + "," + currentTime.toFixed(3)
+      };
+    }
+    const sequenceStartTime = this.getStartTime();
+    const loopSegmentMediaEndTimestamp = this.getLoopSegmentMediaEndTimestamp();
+    const offset = getOffset({
+      mediaTimestamp,
+      targetTime,
+      sequenceStartTime
+    });
+    const duration = getDurationOfNode({
+      bufferDuration: node.buffer?.duration ?? 0,
+      loopSegmentMediaEndTimestamp,
+      offset,
+      originalUnloopedMediaTimestamp
+    });
+    const scheduledTime = getScheduledTime({
+      mediaTimestamp,
+      targetTime,
+      currentTime,
+      sequenceStartTime
+    });
     return this.sharedAudioContext.scheduleAudioNode({
       node,
       mediaTimestamp,
-      targetTime,
       currentTime,
-      sequenceEndTime: this.getEndTime(),
-      sequenceStartTime: this.getStartTime(),
-      debugAudioScheduling: this.debugAudioScheduling
+      scheduledTime,
+      duration,
+      offset,
+      originalUnloopedMediaTimestamp
     });
   };
-  getAudioPlaybackTime(currentTime) {
-    if (!this.sharedAudioContext) {
-      throw new Error("Shared audio context not found");
-    }
-    const globalTime = (currentTime - this.sharedAudioContext.audioSyncAnchor.value) * this.globalPlaybackRate;
-    const localTime = globalTime - this.sequenceOffset;
-    const trimmedTime = this.getTrimmedTime(localTime);
-    if (trimmedTime !== null) {
-      return trimmedTime;
-    }
-    return localTime * this.playbackRate + (this.trimBefore ?? 0) / this.fps;
-  }
   setVideoFrameCallback(callback) {
     this.onVideoFrameCallback = callback;
   }
@@ -1671,6 +1623,12 @@ class MediaPlayer {
       });
     }
   };
+  audioSyncAnchorChanged = () => {
+    if (!this.audioIteratorManager) {
+      return;
+    }
+    this.audioIteratorManager.destroyIterator();
+  };
 }
 
 // src/on-error.ts
@@ -1696,7 +1654,7 @@ var callOnErrorAndResolve = ({
 
 // src/show-in-timeline.ts
 import { useMemo } from "react";
-import { Internals as Internals7, useVideoConfig } from "remotion";
+import { Internals as Internals5, useVideoConfig } from "remotion";
 var useLoopDisplay = ({
   loop,
   mediaDurationInSeconds,
@@ -1709,7 +1667,7 @@ var useLoopDisplay = ({
     if (!loop || !mediaDurationInSeconds) {
       return;
     }
-    const durationInFrames = Internals7.calculateMediaDuration({
+    const durationInFrames = Internals5.calculateMediaDuration({
       mediaDurationInFrames: mediaDurationInSeconds * fps,
       playbackRate,
       trimAfter,
@@ -1735,7 +1693,7 @@ var useLoopDisplay = ({
 
 // src/use-common-effects.ts
 import { useContext, useLayoutEffect } from "react";
-import { Internals as Internals8 } from "remotion";
+import { Internals as Internals6 } from "remotion";
 var useCommonEffects = ({
   mediaPlayerRef,
   mediaPlayerReady,
@@ -1752,39 +1710,14 @@ var useCommonEffects = ({
   fps,
   sequenceOffset,
   loop,
-  debugAudioScheduling,
   durationInFrames,
   isPremounting,
   isPostmounting,
   currentTime,
   logLevel,
-  sharedAudioContext,
   label
 }) => {
-  const absoluteTime = Internals8.useAbsoluteTimelinePosition();
-  const { playing: playingWhilePremounting } = useContext(Internals8.PremountContext);
-  useLayoutEffect(() => {
-    if (sharedAudioContext?.audioContext && sharedAudioContext.audioSyncAnchor) {
-      setGlobalTimeAnchor({
-        audioContext: sharedAudioContext.audioContext,
-        audioSyncAnchor: sharedAudioContext.audioSyncAnchor,
-        absoluteTimeInSeconds: absoluteTime / fps,
-        globalPlaybackRate,
-        debugAudioScheduling,
-        logLevel
-      });
-    }
-  }, [
-    absoluteTime,
-    globalPlaybackRate,
-    sharedAudioContext,
-    fps,
-    debugAudioScheduling,
-    logLevel
-  ]);
-  if (playingWhilePremounting) {
-    mediaPlayerRef.current?.playAudio();
-  }
+  const sharedAudioContext = useContext(Internals6.SharedAudioContext);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer)
@@ -1802,6 +1735,18 @@ var useCommonEffects = ({
     frame,
     mediaPlayerRef
   ]);
+  useLayoutEffect(() => {
+    if (!sharedAudioContext)
+      return;
+    const { remove } = sharedAudioContext.audioSyncAnchorEmitter.subscribe((event) => {
+      if (event === "changed") {
+        mediaPlayerRef.current?.audioSyncAnchorChanged();
+      }
+    });
+    return () => {
+      remove();
+    };
+  }, [sharedAudioContext, mediaPlayerRef]);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
@@ -1841,22 +1786,22 @@ var useCommonEffects = ({
     if (!mediaPlayer || !mediaPlayerReady) {
       return;
     }
-    mediaPlayer.setGlobalPlaybackRate(globalPlaybackRate);
-  }, [globalPlaybackRate, mediaPlayerReady, mediaPlayerRef]);
+    mediaPlayer.setGlobalPlaybackRate(globalPlaybackRate, currentTimeRef.current);
+  }, [globalPlaybackRate, mediaPlayerReady, mediaPlayerRef, currentTimeRef]);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
       return;
     }
-    mediaPlayer.setLoop(loop);
-  }, [loop, mediaPlayerReady, mediaPlayerRef]);
+    mediaPlayer.setLoop(loop, currentTimeRef.current);
+  }, [loop, mediaPlayerReady, mediaPlayerRef, currentTimeRef]);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
       return;
     }
-    mediaPlayer.setDurationInFrames(durationInFrames);
-  }, [durationInFrames, mediaPlayerReady, mediaPlayerRef]);
+    mediaPlayer.setSequenceDurationInFrames(durationInFrames, currentTimeRef.current);
+  }, [durationInFrames, mediaPlayerReady, mediaPlayerRef, currentTimeRef]);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
@@ -1876,34 +1821,27 @@ var useCommonEffects = ({
     if (!mediaPlayer || !mediaPlayerReady) {
       return;
     }
-    mediaPlayer.setFps(fps);
-  }, [fps, mediaPlayerReady, mediaPlayerRef]);
-  useLayoutEffect(() => {
-    const mediaPlayer = mediaPlayerRef.current;
-    if (!mediaPlayer || !mediaPlayerReady) {
-      return;
-    }
-    mediaPlayer.setSequenceOffset(sequenceOffset);
-  }, [sequenceOffset, mediaPlayerReady, mediaPlayerRef]);
+    mediaPlayer.setFps(fps, currentTimeRef.current);
+  }, [fps, mediaPlayerReady, mediaPlayerRef, currentTimeRef]);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady) {
       return;
     }
-    mediaPlayer.setDebugAudioScheduling(debugAudioScheduling);
-  }, [debugAudioScheduling, mediaPlayerReady, mediaPlayerRef]);
+    mediaPlayer.setSequenceOffset(sequenceOffset, currentTimeRef.current);
+  }, [sequenceOffset, mediaPlayerReady, mediaPlayerRef, currentTimeRef]);
   useLayoutEffect(() => {
     const mediaPlayer = mediaPlayerRef.current;
     if (!mediaPlayer || !mediaPlayerReady)
       return;
     mediaPlayer.seekTo(currentTime).catch(() => {});
-    Internals8.Log.trace({ logLevel, tag: "@remotion/media" }, `[${label}] Updating target time to ${currentTime.toFixed(3)}s`);
+    Internals6.Log.trace({ logLevel, tag: "@remotion/media" }, `[${label}] Updating target time to ${currentTime.toFixed(3)}s`);
   }, [currentTime, logLevel, mediaPlayerReady, label, mediaPlayerRef]);
 };
 
 // src/use-media-in-timeline.ts
-import { useContext as useContext2, useState, useEffect } from "react";
-import { Internals as Internals9, useCurrentFrame } from "remotion";
+import { useContext as useContext2, useEffect, useState } from "react";
+import { Internals as Internals7 } from "remotion";
 var useMediaInTimeline = ({
   volume,
   mediaVolume,
@@ -1920,12 +1858,10 @@ var useMediaInTimeline = ({
   trimAfter,
   controls
 }) => {
-  const parentSequence = useContext2(Internals9.SequenceContext);
-  const startsAt = Internals9.useMediaStartsAt();
-  const { registerSequence, unregisterSequence } = useContext2(Internals9.SequenceManager);
-  const [sequenceId] = useState(() => String(Math.random()));
+  const parentSequence = useContext2(Internals7.SequenceContext);
+  const startsAt = Internals7.useMediaStartsAt();
+  const { registerSequence, unregisterSequence } = useContext2(Internals7.SequenceManager);
   const [mediaId] = useState(() => String(Math.random()));
-  const frame = useCurrentFrame();
   const {
     volumes,
     duration,
@@ -1934,7 +1870,7 @@ var useMediaInTimeline = ({
     rootId,
     isStudio,
     finalDisplayName
-  } = Internals9.useBasicMediaInTimeline({
+  } = Internals7.useBasicMediaInTimeline({
     volume,
     mediaVolume,
     mediaType,
@@ -1954,32 +1890,13 @@ var useMediaInTimeline = ({
     if (!showInTimeline) {
       return;
     }
-    const loopIteration = loopDisplay ? Math.floor(frame / loopDisplay.durationInFrames) : 0;
-    if (loopDisplay) {
-      registerSequence({
-        type: "sequence",
-        premountDisplay,
-        postmountDisplay,
-        parent: parentSequence?.id ?? null,
-        displayName: finalDisplayName,
-        rootId,
-        showInTimeline: true,
-        nonce: nonce.get(),
-        loopDisplay,
-        stack,
-        from: 0,
-        duration,
-        id: sequenceId,
-        controls: null
-      });
-    }
     registerSequence({
       type: mediaType,
       src,
       id: mediaId,
-      duration: loopDisplay?.durationInFrames ?? duration,
-      from: loopDisplay ? loopIteration * loopDisplay.durationInFrames : 0,
-      parent: loopDisplay ? sequenceId : parentSequence?.id ?? null,
+      duration,
+      from: 0,
+      parent: parentSequence?.id ?? null,
       displayName: finalDisplayName,
       rootId,
       volume: volumes,
@@ -1987,17 +1904,14 @@ var useMediaInTimeline = ({
       nonce: nonce.get(),
       startMediaFrom: 0 - startsAt + (trimBefore ?? 0),
       doesVolumeChange,
-      loopDisplay: undefined,
+      loopDisplay,
       playbackRate,
       stack,
-      premountDisplay: null,
-      postmountDisplay: null,
+      premountDisplay,
+      postmountDisplay,
       controls: controls ?? null
     });
     return () => {
-      if (loopDisplay) {
-        unregisterSequence(sequenceId);
-      }
       unregisterSequence(mediaId);
     };
   }, [
@@ -2016,14 +1930,12 @@ var useMediaInTimeline = ({
     premountDisplay,
     registerSequence,
     rootId,
-    sequenceId,
     showInTimeline,
     src,
     stack,
     startsAt,
     unregisterSequence,
     volumes,
-    frame,
     trimBefore
   ]);
   return {
@@ -2044,7 +1956,7 @@ var {
   warnAboutTooHighVolume,
   usePreload,
   SequenceContext
-} = Internals10;
+} = Internals8;
 var AudioForPreviewAssertedShowing = ({
   src,
   playbackRate,
@@ -2062,20 +1974,19 @@ var AudioForPreviewAssertedShowing = ({
   toneFrequency,
   audioStreamIndex,
   fallbackHtml5AudioProps,
-  debugAudioScheduling,
   onError,
   credentials,
   controls
 }) => {
   const videoConfig = useUnsafeVideoConfig();
-  const frame = useCurrentFrame2();
+  const frame = useCurrentFrame();
   const mediaPlayerRef = useRef(null);
   const initialTrimBeforeRef = useRef(trimBefore);
   const initialTrimAfterRef = useRef(trimAfter);
   const [mediaPlayerReady, setMediaPlayerReady] = useState2(false);
   const [shouldFallbackToNativeAudio, setShouldFallbackToNativeAudio] = useState2(false);
   const [playing] = Timeline.usePlayingState();
-  const timelineContext = Internals10.useTimelineContext();
+  const timelineContext = Internals8.useTimelineContext();
   const globalPlaybackRate = timelineContext.playbackRate;
   const sharedAudioContext = useContext3(SharedAudioContext);
   const buffer = useBufferState();
@@ -2126,12 +2037,12 @@ var AudioForPreviewAssertedShowing = ({
     trimBefore,
     controls
   });
-  const bufferingContext = useContext3(Internals10.BufferingContextReact);
+  const bufferingContext = useContext3(Internals8.BufferingContextReact);
   if (!bufferingContext) {
     throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
   }
   const effectiveMuted = muted || mediaMuted || userPreferredVolume <= 0;
-  const isPlayerBuffering = Internals10.useIsPlayerBuffering(bufferingContext);
+  const isPlayerBuffering = Internals8.useIsPlayerBuffering(bufferingContext);
   const initialPlaying = useRef(playing && !isPlayerBuffering);
   const initialIsPremounting = useRef(isPremounting);
   const initialIsPostmounting = useRef(isPostmounting);
@@ -2156,13 +2067,11 @@ var AudioForPreviewAssertedShowing = ({
     fps: videoConfig.fps,
     sequenceOffset,
     loop,
-    debugAudioScheduling,
     durationInFrames: videoConfig.durationInFrames,
     isPremounting,
     isPostmounting,
     currentTime,
     logLevel,
-    sharedAudioContext,
     label: "AudioForPreview"
   });
   useEffect2(() => {
@@ -2170,12 +2079,27 @@ var AudioForPreviewAssertedShowing = ({
       return;
     if (!sharedAudioContext.audioContext)
       return;
-    const { audioContext, audioSyncAnchor, scheduleAudioNode } = sharedAudioContext;
+    const {
+      audioContext,
+      gainNode,
+      audioSyncAnchor,
+      scheduleAudioNode,
+      unscheduleAudioNode
+    } = sharedAudioContext;
+    if (!gainNode) {
+      return;
+    }
     try {
       const player = new MediaPlayer({
         src: preloadedSrc,
         logLevel,
-        sharedAudioContext: { audioContext, audioSyncAnchor, scheduleAudioNode },
+        sharedAudioContext: {
+          audioContext,
+          gainNode,
+          audioSyncAnchor,
+          scheduleAudioNode,
+          unscheduleAudioNode
+        },
         loop,
         trimAfter: initialTrimAfterRef.current,
         trimBefore: initialTrimBeforeRef.current,
@@ -2184,7 +2108,6 @@ var AudioForPreviewAssertedShowing = ({
         playbackRate: initialPlaybackRate.current,
         audioStreamIndex: audioStreamIndex ?? 0,
         debugOverlay: false,
-        debugAudioScheduling,
         bufferState: buffer,
         isPostmounting: initialIsPostmounting.current,
         isPremounting: initialIsPremounting.current,
@@ -2193,7 +2116,8 @@ var AudioForPreviewAssertedShowing = ({
         onVideoFrameCallback: null,
         playing: initialPlaying.current,
         sequenceOffset: initialSequenceOffset.current,
-        credentials
+        credentials,
+        tagType: "audio"
       });
       mediaPlayerRef.current = player;
       player.initialize(currentTimeRef.current, initialMuted.current).then((result) => {
@@ -2211,7 +2135,7 @@ var AudioForPreviewAssertedShowing = ({
           if (action === "fail") {
             throw errorToUse;
           } else {
-            Internals10.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+            Internals8.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
             setShouldFallbackToNativeAudio(true);
           }
         };
@@ -2234,7 +2158,7 @@ var AudioForPreviewAssertedShowing = ({
         if (result.type === "success") {
           setMediaPlayerReady(true);
           setMediaDurationInSeconds(result.durationInSeconds);
-          Internals10.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({
@@ -2247,7 +2171,7 @@ var AudioForPreviewAssertedShowing = ({
         if (action === "fail") {
           throw errorToUse;
         } else {
-          Internals10.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);
         }
       });
@@ -2262,12 +2186,12 @@ var AudioForPreviewAssertedShowing = ({
       if (action === "fail") {
         throw errorToUse;
       }
-      Internals10.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) {
-        Internals10.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;
       }
@@ -2282,7 +2206,6 @@ var AudioForPreviewAssertedShowing = ({
     videoConfig.fps,
     audioStreamIndex,
     disallowFallbackToHtml5Audio,
-    debugAudioScheduling,
     buffer,
     onError,
     credentials
@@ -2326,14 +2249,13 @@ var AudioForPreview = ({
   toneFrequency,
   audioStreamIndex,
   fallbackHtml5AudioProps,
-  debugAudioScheduling,
   onError,
   credentials,
   controls
 }) => {
   const preloadedSrc = usePreload(src);
-  const defaultLogLevel = Internals10.useLogLevel();
-  const frame = useCurrentFrame2();
+  const defaultLogLevel = Internals8.useLogLevel();
+  const frame = useCurrentFrame();
   const videoConfig = useVideoConfig2();
   const currentTime = frame / videoConfig.fps;
   const showShow = useMemo2(() => {
@@ -2376,7 +2298,6 @@ var AudioForPreview = ({
     stack,
     disallowFallbackToHtml5Audio: disallowFallbackToHtml5Audio ?? false,
     toneFrequency,
-    debugAudioScheduling: debugAudioScheduling ?? false,
     onError,
     credentials,
     fallbackHtml5AudioProps,
@@ -2389,22 +2310,22 @@ import { useContext as useContext4, useLayoutEffect as useLayoutEffect2, useMemo
 import {
   cancelRender as cancelRender2,
   Html5Audio,
-  Internals as Internals18,
+  Internals as Internals16,
   random,
-  useCurrentFrame as useCurrentFrame3,
+  useCurrentFrame as useCurrentFrame2,
   useDelayRender,
   useRemotionEnvironment
 } from "remotion";
 
 // src/caches.ts
 import React2 from "react";
-import { cancelRender, Internals as Internals15 } from "remotion";
+import { cancelRender, Internals as Internals13 } from "remotion";
 
 // src/audio-extraction/audio-manager.ts
-import { Internals as Internals12 } from "remotion";
+import { Internals as Internals10 } from "remotion";
 
 // src/audio-extraction/audio-iterator.ts
-import { Internals as Internals11 } from "remotion";
+import { Internals as Internals9 } from "remotion";
 
 // src/audio-extraction/audio-cache.ts
 var makeAudioCache = () => {
@@ -2483,7 +2404,7 @@ var warnAboutMatroskaOnce = (src, logLevel) => {
     return;
   }
   warned[src] = true;
-  Internals11.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,
@@ -2551,7 +2472,7 @@ var makeAudioIterator2 = ({
     if (openTimestamps.length > 0) {
       const first = openTimestamps[0];
       const last = openTimestamps[openTimestamps.length - 1];
-      Internals11.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 = () => {
@@ -2648,7 +2569,7 @@ var makeAudioManager = () => {
       if (seenKeys.has(key)) {
         iterator.prepareForDeletion();
         iterators.splice(iterators.indexOf(iterator), 1);
-        Internals12.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);
     }
@@ -2669,7 +2590,7 @@ var makeAudioManager = () => {
       attempts++;
     }
     if ((await getTotalCacheStats()).totalSize > maxCacheSize && attempts >= maxAttempts) {
-      Internals12.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)) {
@@ -2738,7 +2659,7 @@ var makeAudioManager = () => {
 };
 
 // src/video-extraction/keyframe-manager.ts
-import { Internals as Internals14 } from "remotion";
+import { Internals as Internals12 } from "remotion";
 
 // src/render-timestamp-range.ts
 var renderTimestampRange = (timestamps) => {
@@ -2752,7 +2673,7 @@ var renderTimestampRange = (timestamps) => {
 };
 
 // src/video-extraction/keyframe-bank.ts
-import { Internals as Internals13 } from "remotion";
+import { Internals as Internals11 } from "remotion";
 
 // src/video-extraction/get-allocation-size.ts
 var getAllocationSize = (sample) => {
@@ -2815,7 +2736,7 @@ var makeKeyframeBank = async ({
       }
     }
     if (deletedTimestamps.length > 0) {
-      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)}`);
+      Internals11.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) => {
@@ -2838,7 +2759,7 @@ var makeKeyframeBank = async ({
     frameTimestamps.push(frame.timestamp);
     allocationSize += getAllocationSize(frame);
     lastUsed = Date.now();
-    Internals13.Log.trace({ logLevel, tag: "@remotion/media" }, `Added frame at ${frame.timestamp}sec to bank`);
+    Internals11.Log.trace({ logLevel, tag: "@remotion/media" }, `Added frame at ${frame.timestamp}sec to bank`);
   };
   const ensureEnoughFramesForTimestamp = async (timestampInSeconds, logLevel, fps) => {
     while (!hasDecodedEnoughForTimestamp(timestampInSeconds)) {
@@ -2893,7 +2814,7 @@ var makeKeyframeBank = async ({
     throw new Error("No first frame found");
   }
   const startTimestampInSeconds = firstFrame.value.timestamp;
-  Internals13.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec`);
+  Internals11.Log.verbose({ logLevel: parentLogLevel, tag: "@remotion/media" }, `Creating keyframe bank from ${startTimestampInSeconds}sec`);
   addFrame(firstFrame.value, parentLogLevel);
   const getRangeOfTimestamps = () => {
     if (frameTimestamps.length === 0) {
@@ -2911,7 +2832,7 @@ var makeKeyframeBank = async ({
   const prepareForDeletion = (logLevel, reason) => {
     const range = getRangeOfTimestamps();
     if (range) {
-      Internals13.Log.verbose({ logLevel, tag: "@remotion/media" }, `Preparing for deletion (${reason}) of keyframe bank from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec`);
+      Internals11.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()) {
@@ -2984,10 +2905,10 @@ var makeKeyframeManager = () => {
         if (size === 0) {
           continue;
         }
-        Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Open frames for src ${src}: ${renderTimestampRange(timestamps)}`);
+        Internals12.Log.verbose({ logLevel, tag: "@remotion/media" }, `Open frames for src ${src}: ${renderTimestampRange(timestamps)}`);
       }
     }
-    Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Video cache stats: ${count} open frames, ${totalSize} bytes`);
+    Internals12.Log.verbose({ logLevel, tag: "@remotion/media" }, `Video cache stats: ${count} open frames, ${totalSize} bytes`);
   };
   const getCacheStats = () => {
     let count = 0;
@@ -3041,7 +2962,7 @@ var makeKeyframeManager = () => {
       const { framesDeleted } = mostInThePastBank.prepareForDeletion(logLevel, "deleted oldest keyframe bank to stay under max cache size");
       sources[mostInThePastSrc].splice(mostInThePastIndex, 1);
       if (range) {
-        Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${framesDeleted} frames for src ${mostInThePastSrc} from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec to free up memory.`);
+        Internals12.Log.verbose({ logLevel, tag: "@remotion/media" }, `Deleted ${framesDeleted} frames for src ${mostInThePastSrc} from ${range?.firstTimestamp}sec to ${range?.lastTimestamp}sec to free up memory.`);
       }
     }
     return { finish: false };
@@ -3055,12 +2976,12 @@ var makeKeyframeManager = () => {
       if (finish) {
         break;
       }
-      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));
+      Internals12.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) {
-      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.`);
+      Internals12.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 = ({
@@ -3081,7 +3002,7 @@ var makeKeyframeManager = () => {
       }
       if (range.lastTimestamp < threshold) {
         bank.prepareForDeletion(logLevel, "cleared before threshold " + threshold);
-        Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `[Video] Cleared frames for src ${src} from ${range.firstTimestamp}sec to ${range.lastTimestamp}sec`);
+        Internals12.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 {
@@ -3103,7 +3024,7 @@ var makeKeyframeManager = () => {
     const existingBanks = sources[src] ?? [];
     const existingBank = existingBanks?.find((bank) => bank.canSatisfyTimestamp(timestamp));
     if (!existingBank) {
-      Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, `Creating new keyframe bank for src ${src} at timestamp ${timestamp}`);
+      Internals12.Log.trace({ logLevel, tag: "@remotion/media" }, `Creating new keyframe bank for src ${src} at timestamp ${timestamp}`);
       const newKeyframeBank = await makeKeyframeBank({
         videoSampleSink,
         logLevel,
@@ -3114,10 +3035,10 @@ var makeKeyframeManager = () => {
       return newKeyframeBank;
     }
     if (existingBank.canSatisfyTimestamp(timestamp)) {
-      Internals14.Log.trace({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists and satisfies timestamp ${timestamp}`);
+      Internals12.Log.trace({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists and satisfies timestamp ${timestamp}`);
       return existingBank;
     }
-    Internals14.Log.verbose({ logLevel, tag: "@remotion/media" }, `Keyframe bank exists but frame at time ${timestamp} does not exist anymore.`);
+    Internals12.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({
@@ -3208,20 +3129,20 @@ var getUncachedMaxCacheSize = (logLevel) => {
     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}`));
     }
-    Internals15.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set using "mediaCacheSizeInBytes": ${(window.remotion_mediaCacheSizeInBytes / 1024 / 1024).toFixed(1)} MB`);
+    Internals13.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) {
-      Internals15.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!)`);
+      Internals13.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) {
-      Internals15.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)`);
+      Internals13.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;
     }
-    Internals15.Log.verbose({ logLevel, tag: "@remotion/media" }, `Using cache size set based on available memory (50% of available memory): ${(value / 1024 / 1024).toFixed(1)} MB`);
+    Internals13.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;
@@ -3235,7 +3156,7 @@ var getMaxVideoCacheSize = (logLevel) => {
   return cachedMaxCacheSize;
 };
 var useMaxMediaCacheSize = (logLevel) => {
-  const context = React2.useContext(Internals15.MaxMediaCacheSizeContext);
+  const context = React2.useContext(Internals13.MaxMediaCacheSizeContext);
   if (context === null) {
     return getMaxVideoCacheSize(logLevel);
   }
@@ -3489,7 +3410,7 @@ var combineAudioDataAndClosePrevious = (audioDataArray) => {
 };
 
 // src/get-sink.ts
-import { Internals as Internals16 } from "remotion";
+import { Internals as Internals14 } from "remotion";
 
 // src/video-extraction/get-frames-since-keyframe.ts
 import {
@@ -3644,7 +3565,7 @@ var getSink = (src, logLevel, credentials) => {
   const cacheKey = credentials ? `${src}::${credentials}` : src;
   let promise = sinkPromises[cacheKey];
   if (!promise) {
-    Internals16.Log.verbose({
+    Internals14.Log.verbose({
       logLevel,
       tag: "@remotion/media"
     }, `Sink for ${src} was not found, creating new sink`);
@@ -3785,7 +3706,7 @@ var extractAudio = (params) => {
 };
 
 // src/video-extraction/extract-frame.ts
-import { Internals as Internals17 } from "remotion";
+import { Internals as Internals15 } from "remotion";
 var extractFrameInternal = async ({
   src,
   timeInSeconds: unloopedTimeInSeconds,
@@ -3867,7 +3788,7 @@ var extractFrameInternal = async ({
       durationInSeconds: await sink.getDuration()
     };
   } catch (err) {
-    Internals17.Log.info({ logLevel, tag: "@remotion/media" }, `Error decoding ${src} at time ${timeInSeconds}: ${err}`, err);
+    Internals15.Log.info({ logLevel, tag: "@remotion/media" }, `Error decoding ${src} at time ${timeInSeconds}: ${err}`, err);
     return { type: "cannot-decode", durationInSeconds: mediaDurationInSeconds };
   }
 };
@@ -4271,13 +4192,13 @@ var AudioForRendering = ({
   onError,
   credentials
 }) => {
-  const defaultLogLevel = Internals18.useLogLevel();
+  const defaultLogLevel = Internals16.useLogLevel();
   const logLevel = overriddenLogLevel ?? defaultLogLevel;
-  const frame = useCurrentFrame3();
-  const absoluteFrame = Internals18.useTimelinePosition();
-  const videoConfig = Internals18.useUnsafeVideoConfig();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext4(Internals18.RenderAssetManager);
-  const startsAt = Internals18.useMediaStartsAt();
+  const frame = useCurrentFrame2();
+  const absoluteFrame = Internals16.useTimelinePosition();
+  const videoConfig = Internals16.useUnsafeVideoConfig();
+  const { registerRenderAsset, unregisterRenderAsset } = useContext4(Internals16.RenderAssetManager);
+  const startsAt = Internals16.useMediaStartsAt();
   const environment = useRemotionEnvironment();
   if (!videoConfig) {
     throw new Error("No video config found");
@@ -4288,7 +4209,7 @@ var AudioForRendering = ({
   const { fps } = videoConfig;
   const { delayRender, continueRender } = useDelayRender();
   const [replaceWithHtml5Audio, setReplaceWithHtml5Audio] = useState3(false);
-  const sequenceContext = useContext4(Internals18.SequenceContext);
+  const sequenceContext = useContext4(Internals16.SequenceContext);
   const id = useMemo3(() => `media-audio-${random(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
@@ -4296,7 +4217,7 @@ var AudioForRendering = ({
     sequenceContext?.durationInFrames
   ]);
   const maxCacheSize = useMaxMediaCacheSize(logLevel);
-  const audioEnabled = Internals18.useAudioEnabled();
+  const audioEnabled = Internals16.useAudioEnabled();
   useLayoutEffect2(() => {
     const timestamp = frame / fps;
     const durationInSeconds = 1 / fps;
@@ -4347,7 +4268,7 @@ var AudioForRendering = ({
         if (action === "fail") {
           cancelRender2(errorToUse);
         }
-        Internals18.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+        Internals16.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
         setReplaceWithHtml5Audio(true);
       };
       if (result.type === "unknown-container-format") {
@@ -4374,12 +4295,12 @@ var AudioForRendering = ({
         frame,
         startsAt
       });
-      const volume = Internals18.evaluateVolume({
+      const volume = Internals16.evaluateVolume({
         volume: volumeProp,
         frame: volumePropsFrame,
         mediaVolume: 1
       });
-      Internals18.warnAboutTooHighVolume(volume);
+      Internals16.warnAboutTooHighVolume(volume);
       if (audio && volume > 0) {
         applyVolume(audio.data, volume);
         registerRenderAsset({
@@ -4456,7 +4377,7 @@ var AudioForRendering = ({
 
 // src/audio/audio.tsx
 import { jsx as jsx3 } from "react/jsx-runtime";
-var { validateMediaProps } = Internals19;
+var { validateMediaProps } = Internals17;
 var audioSchema = {
   volume: {
     type: "number",
@@ -4505,11 +4426,11 @@ var AudioInner = (props) => {
     })
   });
 };
-var Audio = Internals19.wrapInSchema(AudioInner, audioSchema);
-Internals19.addSequenceStackTraces(Audio);
+var Audio = Internals17.wrapInSchema(AudioInner, audioSchema);
+Internals17.addSequenceStackTraces(Audio);
 
 // src/video/video.tsx
-import { Internals as Internals23, Sequence as Sequence2, useRemotionEnvironment as useRemotionEnvironment4 } from "remotion";
+import { Internals as Internals21, Sequence as Sequence2, useRemotionEnvironment as useRemotionEnvironment4 } from "remotion";
 
 // src/video/video-for-preview.tsx
 import {
@@ -4522,9 +4443,9 @@ import {
 } from "react";
 import {
   Html5Video,
-  Internals as Internals21,
+  Internals as Internals19,
   useBufferState as useBufferState2,
-  useCurrentFrame as useCurrentFrame4,
+  useCurrentFrame as useCurrentFrame3,
   useVideoConfig as useVideoConfig3
 } from "remotion";
 
@@ -4552,7 +4473,7 @@ var getCachedVideoFrame = (src) => {
 };
 
 // src/video/warn-object-fit-css.ts
-import { Internals as Internals20 } from "remotion";
+import { Internals as Internals18 } from "remotion";
 var OBJECT_FIT_CLASS_PATTERN = /\bobject-(contain|cover|fill|none|scale-down)\b/;
 var warnedStyle = false;
 var warnedClassName = false;
@@ -4563,11 +4484,11 @@ var warnAboutObjectFitInStyleOrClassName = ({
 }) => {
   if (!warnedStyle && style?.objectFit) {
     warnedStyle = true;
-    Internals20.Log.warn({ logLevel, tag: "@remotion/media" }, "Use the `objectFit` prop instead of the `style` prop.");
+    Internals18.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;
-    Internals20.Log.warn({ logLevel, tag: "@remotion/media" }, "Use the `objectFit` prop instead of `object-*` CSS class names.");
+    Internals18.Log.warn({ logLevel, tag: "@remotion/media" }, "Use the `objectFit` prop instead of `object-*` CSS class names.");
   }
 };
 
@@ -4585,7 +4506,7 @@ var {
   usePreload: usePreload2,
   SequenceContext: SequenceContext2,
   SequenceVisibilityToggleContext
-} = Internals21;
+} = Internals19;
 var VideoForPreviewAssertedShowing = ({
   src: unpreloadedSrc,
   style,
@@ -4606,7 +4527,6 @@ var VideoForPreviewAssertedShowing = ({
   fallbackOffthreadVideoProps,
   audioStreamIndex,
   debugOverlay,
-  debugAudioScheduling,
   headless,
   onError,
   credentials,
@@ -4617,7 +4537,7 @@ var VideoForPreviewAssertedShowing = ({
   const src = usePreload2(unpreloadedSrc);
   const canvasRef = useRef2(null);
   const videoConfig = useUnsafeVideoConfig2();
-  const frame = useCurrentFrame4();
+  const frame = useCurrentFrame3();
   const mediaPlayerRef = useRef2(null);
   const initialTrimBeforeRef = useRef2(trimBefore);
   const initialTrimAfterRef = useRef2(trimAfter);
@@ -4625,7 +4545,7 @@ var VideoForPreviewAssertedShowing = ({
   const [mediaPlayerReady, setMediaPlayerReady] = useState4(false);
   const [shouldFallbackToNativeVideo, setShouldFallbackToNativeVideo] = useState4(false);
   const [playing] = Timeline2.usePlayingState();
-  const timelineContext = Internals21.useTimelineContext();
+  const timelineContext = Internals19.useTimelineContext();
   const globalPlaybackRate = timelineContext.playbackRate;
   const sharedAudioContext = useContext5(SharedAudioContext2);
   const buffer = useBufferState2();
@@ -4675,19 +4595,19 @@ var VideoForPreviewAssertedShowing = ({
   const currentTimeRef = useRef2(currentTime);
   currentTimeRef.current = currentTime;
   const preloadedSrc = usePreload2(src);
-  const buffering = useContext5(Internals21.BufferingContextReact);
+  const buffering = useContext5(Internals19.BufferingContextReact);
   if (!buffering) {
     throw new Error("useMediaPlayback must be used inside a <BufferingContext>");
   }
   const effectiveMuted = isSequenceHidden || muted || mediaMuted || userPreferredVolume <= 0;
-  const isPlayerBuffering = Internals21.useIsPlayerBuffering(buffering);
+  const isPlayerBuffering = Internals19.useIsPlayerBuffering(buffering);
   const initialPlaying = useRef2(playing && !isPlayerBuffering);
   const initialIsPremounting = useRef2(isPremounting);
   const initialIsPostmounting = useRef2(isPostmounting);
   const initialGlobalPlaybackRate = useRef2(globalPlaybackRate);
   const initialPlaybackRate = useRef2(playbackRate);
   const initialMuted = useRef2(effectiveMuted);
-  const initialDurationInFrames = useRef2(videoConfig.durationInFrames);
+  const initialSequenceDuration = useRef2(videoConfig.durationInFrames);
   const initialSequenceOffset = useRef2(sequenceOffset);
   const hasDrawnRealFrameRef = useRef2(false);
   const isPremountingRef = useRef2(isPremounting);
@@ -4732,13 +4652,28 @@ var VideoForPreviewAssertedShowing = ({
       return;
     if (!sharedAudioContext.audioContext)
       return;
-    const { audioContext, audioSyncAnchor, scheduleAudioNode } = sharedAudioContext;
+    const {
+      audioContext,
+      gainNode,
+      audioSyncAnchor,
+      scheduleAudioNode,
+      unscheduleAudioNode
+    } = sharedAudioContext;
+    if (!gainNode) {
+      return;
+    }
     try {
       const player = new MediaPlayer({
         canvas: canvasRef.current,
         src: preloadedSrc,
         logLevel,
-        sharedAudioContext: { audioContext, audioSyncAnchor, scheduleAudioNode },
+        sharedAudioContext: {
+          audioContext,
+          gainNode,
+          audioSyncAnchor,
+          scheduleAudioNode,
+          unscheduleAudioNode
+        },
         loop,
         trimAfter: initialTrimAfterRef.current,
         trimBefore: initialTrimBeforeRef.current,
@@ -4746,16 +4681,16 @@ var VideoForPreviewAssertedShowing = ({
         playbackRate: initialPlaybackRate.current,
         audioStreamIndex,
         debugOverlay,
-        debugAudioScheduling,
         bufferState: buffer,
         isPremounting: initialIsPremounting.current,
         isPostmounting: initialIsPostmounting.current,
         globalPlaybackRate: initialGlobalPlaybackRate.current,
-        durationInFrames: initialDurationInFrames.current,
+        durationInFrames: initialSequenceDuration.current,
         onVideoFrameCallback: initialOnVideoFrameRef.current ?? null,
         playing: initialPlaying.current,
         sequenceOffset: initialSequenceOffset.current,
-        credentials
+        credentials,
+        tagType: "video"
       });
       mediaPlayerRef.current = player;
       player.initialize(currentTimeRef.current, initialMuted.current).then((result) => {
@@ -4773,7 +4708,7 @@ var VideoForPreviewAssertedShowing = ({
           if (action === "fail") {
             throw errorToUse;
           }
-          Internals21.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+          Internals19.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
           setShouldFallbackToNativeVideo(true);
         };
         if (result.type === "unknown-container-format") {
@@ -4808,7 +4743,7 @@ var VideoForPreviewAssertedShowing = ({
         if (action === "fail") {
           throw errorToUse;
         }
-        Internals21.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] Failed to initialize MediaPlayer", errorToUse);
+        Internals19.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] Failed to initialize MediaPlayer", errorToUse);
         setShouldFallbackToNativeVideo(true);
       });
     } catch (error) {
@@ -4822,12 +4757,12 @@ var VideoForPreviewAssertedShowing = ({
       if (action === "fail") {
         throw errorToUse;
       }
-      Internals21.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer initialization failed", errorToUse);
+      Internals19.Log.error({ logLevel, tag: "@remotion/media" }, "[VideoForPreview] MediaPlayer initialization failed", errorToUse);
       setShouldFallbackToNativeVideo(true);
     }
     return () => {
       if (mediaPlayerRef.current) {
-        Internals21.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Disposing MediaPlayer`);
+        Internals19.Log.trace({ logLevel, tag: "@remotion/media" }, `[VideoForPreview] Disposing MediaPlayer`);
         mediaPlayerRef.current.dispose();
         mediaPlayerRef.current = null;
       }
@@ -4839,7 +4774,6 @@ var VideoForPreviewAssertedShowing = ({
     audioStreamIndex,
     buffer,
     debugOverlay,
-    debugAudioScheduling,
     disallowFallbackToOffthreadVideo,
     logLevel,
     loop,
@@ -4851,7 +4785,7 @@ var VideoForPreviewAssertedShowing = ({
   ]);
   warnAboutObjectFitInStyleOrClassName({ style, className, logLevel });
   const classNameValue = useMemo4(() => {
-    return [Internals21.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals21.truthy).join(" ");
+    return [Internals19.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals19.truthy).join(" ");
   }, [className]);
   useCommonEffects({
     mediaPlayerRef,
@@ -4869,13 +4803,11 @@ var VideoForPreviewAssertedShowing = ({
     fps: videoConfig.fps,
     sequenceOffset,
     loop,
-    debugAudioScheduling,
     durationInFrames: videoConfig.durationInFrames,
     isPremounting,
     isPostmounting,
     currentTime,
     logLevel,
-    sharedAudioContext,
     label: "VideoForPreview"
   });
   useLayoutEffect3(() => {
@@ -4927,7 +4859,7 @@ var VideoForPreviewAssertedShowing = ({
   });
 };
 var VideoForPreview = (props) => {
-  const frame = useCurrentFrame4();
+  const frame = useCurrentFrame3();
   const videoConfig = useVideoConfig3();
   const currentTime = frame / videoConfig.fps;
   const showShow = useMemo4(() => {
@@ -4969,10 +4901,10 @@ import {
   useState as useState5
 } from "react";
 import {
-  Internals as Internals22,
+  Internals as Internals20,
   Loop,
   random as random2,
-  useCurrentFrame as useCurrentFrame5,
+  useCurrentFrame as useCurrentFrame4,
   useDelayRender as useDelayRender2,
   useRemotionEnvironment as useRemotionEnvironment3,
   useVideoConfig as useVideoConfig4
@@ -5007,12 +4939,12 @@ var VideoForRendering = ({
   if (!src) {
     throw new TypeError("No `src` was passed to <Video>.");
   }
-  const frame = useCurrentFrame5();
-  const absoluteFrame = Internals22.useTimelinePosition();
+  const frame = useCurrentFrame4();
+  const absoluteFrame = Internals20.useTimelinePosition();
   const { fps } = useVideoConfig4();
-  const { registerRenderAsset, unregisterRenderAsset } = useContext6(Internals22.RenderAssetManager);
-  const startsAt = Internals22.useMediaStartsAt();
-  const sequenceContext = useContext6(Internals22.SequenceContext);
+  const { registerRenderAsset, unregisterRenderAsset } = useContext6(Internals20.RenderAssetManager);
+  const startsAt = Internals20.useMediaStartsAt();
+  const sequenceContext = useContext6(Internals20.SequenceContext);
   const id = useMemo5(() => `media-video-${random2(src)}-${sequenceContext?.cumulatedFrom}-${sequenceContext?.relativeFrom}-${sequenceContext?.durationInFrames}`, [
     src,
     sequenceContext?.cumulatedFrom,
@@ -5023,8 +4955,8 @@ var VideoForRendering = ({
   const { delayRender, continueRender, cancelRender: cancelRender3 } = useDelayRender2();
   const canvasRef = useRef3(null);
   const [replaceWithOffthreadVideo, setReplaceWithOffthreadVideo] = useState5(false);
-  const audioEnabled = Internals22.useAudioEnabled();
-  const videoEnabled = Internals22.useVideoEnabled();
+  const audioEnabled = Internals20.useAudioEnabled();
+  const videoEnabled = Internals20.useVideoEnabled();
   const maxCacheSize = useMaxMediaCacheSize(logLevel);
   const [error, setError] = useState5(null);
   if (error) {
@@ -5089,7 +5021,7 @@ var VideoForRendering = ({
           return;
         }
         if (window.remotion_isMainTab) {
-          Internals22.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
+          Internals20.Log.warn({ logLevel, tag: "@remotion/media" }, fallbackMessage);
         }
         setReplaceWithOffthreadVideo({
           durationInSeconds: mediaDurationInSeconds
@@ -5144,12 +5076,12 @@ var VideoForRendering = ({
         frame,
         startsAt
       });
-      const volume = Internals22.evaluateVolume({
+      const volume = Internals20.evaluateVolume({
         volume: volumeProp,
         frame: volumePropsFrame,
         mediaVolume: 1
       });
-      Internals22.warnAboutTooHighVolume(volume);
+      Internals20.warnAboutTooHighVolume(volume);
       if (audio && volume > 0) {
         applyVolume(audio.data, volume);
         registerRenderAsset({
@@ -5207,7 +5139,7 @@ var VideoForRendering = ({
   ]);
   warnAboutObjectFitInStyleOrClassName({ style, className, logLevel });
   const classNameValue = useMemo5(() => {
-    return [Internals22.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals22.truthy).join(" ");
+    return [Internals20.OBJECTFIT_CONTAIN_CLASS_NAME, className].filter(Internals20.truthy).join(" ");
   }, [className]);
   const styleWithObjectFit = useMemo5(() => {
     return {
@@ -5216,7 +5148,7 @@ var VideoForRendering = ({
     };
   }, [objectFitProp, style]);
   if (replaceWithOffthreadVideo) {
-    const fallback = /* @__PURE__ */ jsx5(Internals22.InnerOffthreadVideo, {
+    const fallback = /* @__PURE__ */ jsx5(Internals20.InnerOffthreadVideo, {
       src,
       playbackRate: playbackRate ?? 1,
       muted: muted ?? false,
@@ -5256,7 +5188,7 @@ var VideoForRendering = ({
       }
       return /* @__PURE__ */ jsx5(Loop, {
         layout: "none",
-        durationInFrames: Internals22.calculateMediaDuration({
+        durationInFrames: Internals20.calculateMediaDuration({
           trimAfter: trimAfterValue,
           mediaDurationInFrames: replaceWithOffthreadVideo.durationInSeconds * fps,
           playbackRate,
@@ -5279,7 +5211,7 @@ var VideoForRendering = ({
 
 // src/video/video.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
-var { validateMediaTrimProps, resolveTrimProps, validateMediaProps: validateMediaProps2 } = Internals23;
+var { validateMediaTrimProps, resolveTrimProps, validateMediaProps: validateMediaProps2 } = Internals21;
 var videoSchema = {
   volume: {
     type: "number",
@@ -5349,7 +5281,6 @@ var InnerVideo = ({
   toneFrequency,
   showInTimeline,
   debugOverlay,
-  debugAudioScheduling,
   headless,
   onError,
   credentials,
@@ -5422,7 +5353,6 @@ var InnerVideo = ({
     disallowFallbackToOffthreadVideo,
     fallbackOffthreadVideoProps,
     debugOverlay: debugOverlay ?? false,
-    debugAudioScheduling: debugAudioScheduling ?? false,
     headless: headless ?? false,
     onError,
     credentials,
@@ -5454,7 +5384,6 @@ var VideoInner = ({
   stack,
   toneFrequency,
   debugOverlay,
-  debugAudioScheduling,
   headless,
   onError,
   credentials,
@@ -5464,7 +5393,7 @@ var VideoInner = ({
   from,
   durationInFrames
 }) => {
-  const fallbackLogLevel = Internals23.useLogLevel();
+  const fallbackLogLevel = Internals21.useLogLevel();
   return /* @__PURE__ */ jsx6(Sequence2, {
     layout: "none",
     from: from ?? 0,
@@ -5493,7 +5422,6 @@ var VideoInner = ({
       toneFrequency: toneFrequency ?? 1,
       stack,
       debugOverlay: debugOverlay ?? false,
-      debugAudioScheduling: debugAudioScheduling ?? false,
       headless: headless ?? false,
       onError,
       credentials,
@@ -5503,8 +5431,8 @@ var VideoInner = ({
     })
   });
 };
-var Video = Internals23.wrapInSchema(VideoInner, videoSchema);
-Internals23.addSequenceStackTraces(Video);
+var Video = Internals21.wrapInSchema(VideoInner, videoSchema);
+Internals21.addSequenceStackTraces(Video);
 
 // src/index.ts
 var experimental_Audio = Audio;