@remotion/media 4.0.430 → 4.0.432

package/dist/make-iterator-with-priming.d.ts

@@ -0,0 +1,6 @@
+import type { AudioBufferSink, WrappedAudioBuffer } from 'mediabunny';
+export declare const makeIteratorWithPriming: ({ audioSink, timeToSeek, maximumTimestamp, }: {
+    audioSink: AudioBufferSink;
+    timeToSeek: number;
+    maximumTimestamp: number;
+}) => AsyncGenerator<WrappedAudioBuffer, void, unknown>;

package/dist/media-player.d.ts

@@ -1,5 +1,6 @@
 import type { LogLevel, useBufferState } from 'remotion';
 import { type AudioIteratorManager } from './audio-iterator-manager';
+import type { SharedAudioContextForMediaPlayer } from './shared-audio-context-for-media-player';
 import type { VideoIteratorManager } from './video-iterator-manager';
 export type MediaPlayerInitResult = {
     type: 'success';
@@ -26,7 +27,7 @@ export declare class MediaPlayer {
     private sharedAudioContext;
     audioIteratorManager: AudioIteratorManager | null;
     videoIteratorManager: VideoIteratorManager | null;
-    private audioSyncAnchor;
+    private sequenceOffset;
     private playing;
     private loop;
     private fps;
@@ -35,6 +36,7 @@ export declare class MediaPlayer {
     private durationInFrames;
     private totalDuration;
     private debugOverlay;
+    private debugAudioScheduling;
     private nonceManager;
     private onVideoFrameCallback;
     private initializationPromise;
@@ -42,11 +44,11 @@ export declare class MediaPlayer {
     private isPremounting;
     private isPostmounting;
     private seekPromiseChain;
-    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBefore, trimAfter, playbackRate, globalPlaybackRate, audioStreamIndex, fps, debugOverlay, bufferState, isPremounting, isPostmounting, durationInFrames, onVideoFrameCallback, playing }: {
+    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBefore, trimAfter, playbackRate, globalPlaybackRate, audioStreamIndex, fps, debugOverlay, debugAudioScheduling, bufferState, isPremounting, isPostmounting, durationInFrames, onVideoFrameCallback, playing, sequenceOffset }: {
         canvas: HTMLCanvasElement | OffscreenCanvas | null;
         src: string;
         logLevel: LogLevel;
-        sharedAudioContext: AudioContext | null;
+        sharedAudioContext: SharedAudioContextForMediaPlayer | null;
         loop: boolean;
         trimBefore: number | undefined;
         trimAfter: number | undefined;
@@ -55,12 +57,14 @@ export declare class MediaPlayer {
         audioStreamIndex: number;
         fps: number;
         debugOverlay: boolean;
+        debugAudioScheduling: boolean;
         bufferState: ReturnType<typeof useBufferState>;
         isPremounting: boolean;
         isPostmounting: boolean;
         durationInFrames: number;
         onVideoFrameCallback: null | ((frame: CanvasImageSource) => void);
         playing: boolean;
+        sequenceOffset: number;
     });
     private input;
     private isDisposalError;
@@ -71,8 +75,8 @@ export declare class MediaPlayer {
     private seekToWithQueue;
     seekTo(time: number): Promise<void>;
     private seekToDoNotCallDirectly;
-    playAudio(time: number): Promise<void>;
-    play(time: number): Promise<void>;
+    playAudio(): void;
+    play(): void;
     private delayPlaybackHandleIfNotPremounting;
     pause(): void;
     setMuted(muted: boolean): void;
@@ -82,18 +86,19 @@ export declare class MediaPlayer {
     setTrimBefore(trimBefore: number | undefined, unloopedTimeInSeconds: number): Promise<void>;
     setTrimAfter(trimAfter: number | undefined, unloopedTimeInSeconds: number): Promise<void>;
     setDebugOverlay(debugOverlay: boolean): void;
-    private updateAudioTimeAfterPlaybackRateChange;
+    setDebugAudioScheduling(debugAudioScheduling: boolean): void;
+    private rescheduleAudioChunks;
     setPlaybackRate(rate: number, unloopedTimeInSeconds: number): Promise<void>;
     setGlobalPlaybackRate(rate: number): void;
     setFps(fps: number): void;
     setIsPremounting(isPremounting: boolean): void;
     setIsPostmounting(isPostmounting: boolean): void;
     setLoop(loop: boolean): void;
+    setSequenceOffset(offset: number): void;
     setDurationInFrames(durationInFrames: number): void;
     dispose(): Promise<void>;
     private scheduleAudioNode;
     private getAudioPlaybackTime;
-    private setAudioPlaybackTime;
     setVideoFrameCallback(callback: null | ((frame: CanvasImageSource) => void)): void;
     private drawDebugOverlay;
 }

package/dist/prewarm-iterator-for-looping.d.ts

@@ -8,10 +8,11 @@ export declare const makePrewarmedVideoIteratorCache: (videoSink: CanvasSink) =>
 };
 export type PrewarmedVideoIteratorCache = ReturnType<typeof makePrewarmedVideoIteratorCache>;
 export declare const makePrewarmedAudioIteratorCache: (audioSink: AudioBufferSink) => {
-    prewarmIteratorForLooping: ({ timeToSeek }: {
+    prewarmIteratorForLooping: ({ timeToSeek, maximumTimestamp, }: {
         timeToSeek: number;
+        maximumTimestamp: number;
     }) => void;
-    makeIteratorOrUsePrewarmed: (timeToSeek: number) => AsyncGenerator<WrappedAudioBuffer, void, unknown>;
+    makeIteratorOrUsePrewarmed: (timeToSeek: number, maximumTimestamp: number) => AsyncGenerator<WrappedAudioBuffer, void, unknown>;
     destroy: () => void;
 };
 export type PrewarmedAudioIteratorCache = ReturnType<typeof makePrewarmedAudioIteratorCache>;

package/dist/set-global-time-anchor.d.ts

@@ -0,0 +1,11 @@
+export declare const ALLOWED_GLOBAL_TIME_ANCHOR_SHIFT = 0.1;
+export declare const setGlobalTimeAnchor: ({ audioContext, audioSyncAnchor, absoluteTimeInSeconds, globalPlaybackRate, debugAudioScheduling, logLevel, }: {
+    audioContext: AudioContext;
+    audioSyncAnchor: {
+        value: number;
+    };
+    absoluteTimeInSeconds: number;
+    globalPlaybackRate: number;
+    debugAudioScheduling: boolean;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+}) => void;

package/dist/shared-audio-context-for-media-player.d.ts

@@ -0,0 +1,8 @@
+import type { ScheduleAudioNodeOptions, ScheduleAudioNodeResult } from 'remotion';
+export type SharedAudioContextForMediaPlayer = {
+    audioContext: AudioContext;
+    audioSyncAnchor: {
+        value: number;
+    };
+    scheduleAudioNode: (options: ScheduleAudioNodeOptions) => ScheduleAudioNodeResult;
+};

package/dist/use-common-effects.d.ts

@@ -0,0 +1,32 @@
+import type React from 'react';
+import type { MediaPlayer } from './media-player';
+export declare const useCommonEffects: ({ mediaPlayerRef, mediaPlayerReady, currentTimeRef, playing, isPlayerBuffering, frame, trimBefore, trimAfter, effectiveMuted, userPreferredVolume, playbackRate, globalPlaybackRate, fps, sequenceOffset, loop, debugAudioScheduling, durationInFrames, isPremounting, isPostmounting, currentTime, logLevel, sharedAudioContext, label, }: {
+    readonly mediaPlayerRef: React.RefObject<MediaPlayer | null>;
+    readonly mediaPlayerReady: boolean;
+    readonly currentTimeRef: React.RefObject<number>;
+    readonly playing: boolean;
+    readonly isPlayerBuffering: boolean;
+    readonly frame: number;
+    readonly trimBefore: number | undefined;
+    readonly trimAfter: number | undefined;
+    readonly effectiveMuted: boolean;
+    readonly userPreferredVolume: number;
+    readonly playbackRate: number;
+    readonly globalPlaybackRate: number;
+    readonly fps: number;
+    readonly sequenceOffset: number;
+    readonly loop: boolean;
+    readonly debugAudioScheduling: boolean;
+    readonly durationInFrames: number;
+    readonly isPremounting: boolean;
+    readonly isPostmounting: boolean;
+    readonly currentTime: number;
+    readonly logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    readonly sharedAudioContext: {
+        readonly audioContext: AudioContext | null;
+        readonly audioSyncAnchor: {
+            value: number;
+        };
+    } | null;
+    readonly label: string;
+}) => void;

package/dist/video/props.d.ts

@@ -45,6 +45,7 @@ type OptionalVideoProps = {
     toneFrequency: number;
     showInTimeline: boolean;
     debugOverlay: boolean;
+    debugAudioScheduling: boolean;
     headless: boolean;
     onError: MediaOnError | undefined;
 };

package/dist/video/video-for-preview.d.ts

@@ -22,6 +22,7 @@ type VideoForPreviewProps = {
     readonly fallbackOffthreadVideoProps: FallbackOffthreadVideoProps;
     readonly audioStreamIndex: number;
     readonly debugOverlay: boolean;
+    readonly debugAudioScheduling: boolean;
     readonly headless: boolean;
     readonly onError: MediaOnError | undefined;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.430",
+	"version": "4.0.432",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -23,7 +23,7 @@
 	},
 	"dependencies": {
 		"mediabunny": "1.35.1",
-		"remotion": "4.0.429",
+		"remotion": "4.0.432",
 		"zod": "4.3.6"
 	},
 	"peerDependencies": {
@@ -31,14 +31,14 @@
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.429",
+		"@remotion/eslint-config-internal": "4.0.432",
 		"@vitest/browser-webdriverio": "4.0.9",
 		"eslint": "9.19.0",
 		"react": "19.2.3",
 		"react-dom": "19.2.3",
 		"vitest": "4.0.9",
 		"webdriverio": "9.19.2",
-		"@typescript/native-preview": "7.0.0-dev.20260217.1"
+		"@typescript/native-preview": "7.0.0-dev.20260301.1"
 	},
 	"keywords": [],
 	"publishConfig": {

package/dist/audio/allow-wait.d.ts

@@ -1,6 +0,0 @@
-import type { WrappedAudioBuffer } from 'mediabunny';
-export type AllowWait = {
-    type: 'allow-wait';
-    waitCallback: () => () => void;
-};
-export declare const allowWaitRoutine: (next: Promise<IteratorResult<WrappedAudioBuffer, void>>, waitFn: AllowWait) => Promise<IteratorResult<WrappedAudioBuffer, void>>;

package/dist/audio/allow-wait.js

@@ -1,15 +0,0 @@
-export const allowWaitRoutine = async (next, waitFn) => {
-    const result = await Promise.race([
-        next,
-        new Promise((resolve) => {
-            Promise.resolve().then(() => resolve());
-        }),
-    ]);
-    if (!result) {
-        const unblock = waitFn.waitCallback();
-        const newRes = await next;
-        unblock();
-        return newRes;
-    }
-    return result;
-};

package/dist/audio/audio-for-preview.js

@@ -1,304 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useContext, useEffect, useLayoutEffect, useMemo, useRef, useState, } from 'react';
-import { Internals, Audio as RemotionAudio, useBufferState, useCurrentFrame, useVideoConfig, } from 'remotion';
-import { getTimeInSeconds } from '../get-time-in-seconds';
-import { MediaPlayer } from '../media-player';
-import { useLoopDisplay } from '../show-in-timeline';
-import { useMediaInTimeline } from '../use-media-in-timeline';
-const { useUnsafeVideoConfig, Timeline, SharedAudioContext, useMediaMutedState, useMediaVolumeState, useFrameForVolumeProp, evaluateVolume, warnAboutTooHighVolume, usePreload, SequenceContext, } = Internals;
-const AudioForPreviewAssertedShowing = ({ src, playbackRate, logLevel, muted, volume, loopVolumeCurveBehavior, loop, trimAfter, trimBefore, name, showInTimeline, stack, disallowFallbackToHtml5Audio, toneFrequency, audioStreamIndex, fallbackHtml5AudioProps, }) => {
-    const videoConfig = useUnsafeVideoConfig();
-    const frame = useCurrentFrame();
-    const mediaPlayerRef = useRef(null);
-    const initialTrimBeforeRef = useRef(trimBefore);
-    const initialTrimAfterRef = useRef(trimAfter);
-    const [mediaPlayerReady, setMediaPlayerReady] = useState(false);
-    const [shouldFallbackToNativeAudio, setShouldFallbackToNativeAudio] = useState(false);
-    const [playing] = Timeline.usePlayingState();
-    const timelineContext = useContext(Internals.TimelineContext);
-    const globalPlaybackRate = timelineContext.playbackRate;
-    const sharedAudioContext = useContext(SharedAudioContext);
-    const buffer = useBufferState();
-    const [mediaMuted] = useMediaMutedState();
-    const [mediaVolume] = useMediaVolumeState();
-    const [mediaDurationInSeconds, setMediaDurationInSeconds] = useState(null);
-    const volumePropFrame = useFrameForVolumeProp(loopVolumeCurveBehavior ?? 'repeat');
-    const userPreferredVolume = evaluateVolume({
-        frame: volumePropFrame,
-        volume,
-        mediaVolume,
-    });
-    warnAboutTooHighVolume(userPreferredVolume);
-    if (!videoConfig) {
-        throw new Error('No video config found');
-    }
-    if (!src) {
-        throw new TypeError('No `src` was passed to <NewAudioForPreview>.');
-    }
-    const currentTime = frame / videoConfig.fps;
-    const currentTimeRef = useRef(currentTime);
-    currentTimeRef.current = currentTime;
-    const preloadedSrc = usePreload(src);
-    const parentSequence = useContext(SequenceContext);
-    const isPremounting = Boolean(parentSequence?.premounting);
-    const isPostmounting = Boolean(parentSequence?.postmounting);
-    const loopDisplay = useLoopDisplay({
-        loop,
-        mediaDurationInSeconds,
-        playbackRate,
-        trimAfter,
-        trimBefore,
-    });
-    useMediaInTimeline({
-        volume,
-        mediaVolume,
-        mediaType: 'audio',
-        src,
-        playbackRate,
-        displayName: name ?? null,
-        stack,
-        showInTimeline,
-        premountDisplay: parentSequence?.premountDisplay ?? null,
-        postmountDisplay: parentSequence?.postmountDisplay ?? null,
-        loopDisplay,
-        trimAfter,
-        trimBefore,
-    });
-    const bufferingContext = useContext(Internals.BufferingContextReact);
-    if (!bufferingContext) {
-        throw new Error('useMediaPlayback must be used inside a <BufferingContext>');
-    }
-    const isPlayerBuffering = Internals.useIsPlayerBuffering(bufferingContext);
-    const initialPlaying = useRef(playing && !isPlayerBuffering);
-    const initialIsPremounting = useRef(isPremounting);
-    const initialIsPostmounting = useRef(isPostmounting);
-    const initialGlobalPlaybackRate = useRef(globalPlaybackRate);
-    const initialPlaybackRate = useRef(playbackRate);
-    useEffect(() => {
-        if (!sharedAudioContext)
-            return;
-        if (!sharedAudioContext.audioContext)
-            return;
-        try {
-            const player = new MediaPlayer({
-                src: preloadedSrc,
-                logLevel,
-                sharedAudioContext: sharedAudioContext.audioContext,
-                loop,
-                trimAfter: initialTrimAfterRef.current,
-                trimBefore: initialTrimBeforeRef.current,
-                fps: videoConfig.fps,
-                canvas: null,
-                playbackRate: initialPlaybackRate.current,
-                audioStreamIndex: audioStreamIndex ?? 0,
-                debugOverlay: false,
-                bufferState: buffer,
-                isPostmounting: initialIsPostmounting.current,
-                isPremounting: initialIsPremounting.current,
-                globalPlaybackRate: initialGlobalPlaybackRate.current,
-                onVideoFrameCallback: null,
-                playing: initialPlaying.current,
-            });
-            mediaPlayerRef.current = player;
-            player
-                .initialize(currentTimeRef.current)
-                .then((result) => {
-                if (result.type === 'disposed') {
-                    return;
-                }
-                if (result.type === 'unknown-container-format') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`Unknown container format ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Unknown container format for ${preloadedSrc} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'network-error') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`Network error fetching ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Network error fetching ${preloadedSrc}, falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'cannot-decode') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`Cannot decode ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Cannot decode ${preloadedSrc}, falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'no-tracks') {
-                    if (disallowFallbackToHtml5Audio) {
-                        throw new Error(`No video or audio tracks found for ${preloadedSrc}, and 'disallowFallbackToHtml5Audio' was set.`);
-                    }
-                    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `No video or audio tracks found for ${preloadedSrc}, falling back to <Html5Audio>`);
-                    setShouldFallbackToNativeAudio(true);
-                    return;
-                }
-                if (result.type === 'success') {
-                    setMediaPlayerReady(true);
-                    setMediaDurationInSeconds(result.durationInSeconds);
-                    Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] MediaPlayer initialized successfully`);
-                }
-            })
-                .catch((error) => {
-                Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[AudioForPreview] Failed to initialize MediaPlayer', error);
-                setShouldFallbackToNativeAudio(true);
-            });
-        }
-        catch (error) {
-            Internals.Log.error({ logLevel, tag: '@remotion/media' }, '[AudioForPreview] MediaPlayer initialization failed', error);
-            setShouldFallbackToNativeAudio(true);
-        }
-        return () => {
-            if (mediaPlayerRef.current) {
-                Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] Disposing MediaPlayer`);
-                mediaPlayerRef.current.dispose();
-                mediaPlayerRef.current = null;
-            }
-            setMediaPlayerReady(false);
-            setShouldFallbackToNativeAudio(false);
-        };
-    }, [
-        preloadedSrc,
-        logLevel,
-        sharedAudioContext,
-        currentTimeRef,
-        loop,
-        videoConfig.fps,
-        audioStreamIndex,
-        disallowFallbackToHtml5Audio,
-        buffer,
-    ]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer)
-            return;
-        if (playing && !isPlayerBuffering) {
-            audioPlayer.play(currentTimeRef.current);
-        }
-        else {
-            audioPlayer.pause();
-        }
-    }, [isPlayerBuffering, logLevel, playing]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setTrimBefore(trimBefore, currentTimeRef.current);
-    }, [trimBefore, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setTrimAfter(trimAfter, currentTimeRef.current);
-    }, [trimAfter, mediaPlayerReady]);
-    const effectiveMuted = muted || mediaMuted || userPreferredVolume <= 0;
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady)
-            return;
-        audioPlayer.setMuted(effectiveMuted);
-    }, [effectiveMuted, mediaPlayerReady]);
-    useEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setVolume(userPreferredVolume);
-    }, [userPreferredVolume, mediaPlayerReady]);
-    useEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setPlaybackRate(playbackRate);
-    }, [playbackRate, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setGlobalPlaybackRate(globalPlaybackRate);
-    }, [globalPlaybackRate, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady) {
-            return;
-        }
-        audioPlayer.setFps(videoConfig.fps);
-    }, [videoConfig.fps, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setLoop(loop);
-    }, [loop, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setIsPremounting(isPremounting);
-    }, [isPremounting, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const mediaPlayer = mediaPlayerRef.current;
-        if (!mediaPlayer || !mediaPlayerReady) {
-            return;
-        }
-        mediaPlayer.setIsPostmounting(isPostmounting);
-    }, [isPostmounting, mediaPlayerReady]);
-    useLayoutEffect(() => {
-        const audioPlayer = mediaPlayerRef.current;
-        if (!audioPlayer || !mediaPlayerReady)
-            return;
-        audioPlayer.seekTo(currentTime).catch(() => {
-            // Might be disposed
-        });
-        Internals.Log.trace({ logLevel, tag: '@remotion/media' }, `[AudioForPreview] Updating target time to ${currentTime.toFixed(3)}s`);
-    }, [currentTime, logLevel, mediaPlayerReady]);
-    if (shouldFallbackToNativeAudio && !disallowFallbackToHtml5Audio) {
-        return (_jsx(RemotionAudio, { src: src, muted: muted, volume: volume, startFrom: trimBefore, endAt: trimAfter, playbackRate: playbackRate, loopVolumeCurveBehavior: loopVolumeCurveBehavior, name: name, loop: loop, showInTimeline: showInTimeline, stack: stack ?? undefined, toneFrequency: toneFrequency, audioStreamIndex: audioStreamIndex, pauseWhenBuffering: fallbackHtml5AudioProps?.pauseWhenBuffering, crossOrigin: fallbackHtml5AudioProps?.crossOrigin, ...fallbackHtml5AudioProps }));
-    }
-    return null;
-};
-export const AudioForPreview = ({ loop, src, logLevel, muted, name, volume, loopVolumeCurveBehavior, playbackRate, trimAfter, trimBefore, showInTimeline, stack, disallowFallbackToHtml5Audio, toneFrequency, audioStreamIndex, fallbackHtml5AudioProps, }) => {
-    const preloadedSrc = usePreload(src);
-    const frame = useCurrentFrame();
-    const videoConfig = useVideoConfig();
-    const currentTime = frame / videoConfig.fps;
-    const showShow = useMemo(() => {
-        return (getTimeInSeconds({
-            unloopedTimeInSeconds: currentTime,
-            playbackRate: playbackRate ?? 1,
-            loop: loop ?? false,
-            trimBefore,
-            trimAfter,
-            mediaDurationInSeconds: Infinity,
-            fps: videoConfig.fps,
-            ifNoMediaDuration: 'infinity',
-            src,
-        }) !== null);
-    }, [
-        currentTime,
-        loop,
-        playbackRate,
-        src,
-        trimAfter,
-        trimBefore,
-        videoConfig.fps,
-    ]);
-    if (!showShow) {
-        return null;
-    }
-    return (_jsx(AudioForPreviewAssertedShowing, { audioStreamIndex: audioStreamIndex ?? 0, src: preloadedSrc, playbackRate: playbackRate ?? 1, logLevel: logLevel ??
-            (typeof window !== 'undefined'
-                ? (window.remotion_logLevel ?? 'info')
-                : 'info'), muted: muted ?? false, volume: volume ?? 1, loopVolumeCurveBehavior: loopVolumeCurveBehavior ?? 'repeat', loop: loop ?? false, trimAfter: trimAfter, trimBefore: trimBefore, name: name, showInTimeline: showInTimeline ?? true, stack: stack, disallowFallbackToHtml5Audio: disallowFallbackToHtml5Audio ?? false, toneFrequency: toneFrequency, fallbackHtml5AudioProps: fallbackHtml5AudioProps }));
-};