@remotion/media 4.0.402 → 4.0.404

package/dist/extract-frame-and-audio.d.ts

@@ -1,9 +1,8 @@
-import type { LogLevel } from 'remotion';
 import type { ExtractFrameViaBroadcastChannelResult } from './video-extraction/extract-frame-via-broadcast-channel';
 export declare const extractFrameAndAudio: ({ src, timeInSeconds, logLevel, durationInSeconds, playbackRate, includeAudio, includeVideo, loop, audioStreamIndex, trimAfter, trimBefore, fps, maxCacheSize, }: {
     src: string;
     timeInSeconds: number;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     durationInSeconds: number;
     playbackRate: number;
     includeAudio: boolean;

package/dist/get-sink.d.ts

@@ -1,7 +1,6 @@
-import type { LogLevel } from 'remotion';
 import type { GetSink } from './video-extraction/get-frames-since-keyframe';
 export declare const sinkPromises: Record<string, Promise<GetSink>>;
-export declare const getSink: (src: string, logLevel: LogLevel) => Promise<{
+export declare const getSink: (src: string, logLevel: "error" | "info" | "trace" | "verbose" | "warn") => Promise<{
     getVideo: () => Promise<import("./video-extraction/get-frames-since-keyframe").VideoSinkResult>;
     getAudio: (index: number) => Promise<import("./video-extraction/get-frames-since-keyframe").AudioSinkResult>;
     actualMatroskaTimestamps: {

package/dist/index.d.ts

@@ -10,5 +10,6 @@ export declare const experimental_Audio: import("react").FC<import(".").AudioPro
 export declare const experimental_Video: import("react").FC<import(".").VideoProps>;
 export { AudioForPreview } from './audio/audio-for-preview';
 export { AudioProps, FallbackHtml5AudioProps } from './audio/props';
-export { VideoProps } from './video/props';
+export { MediaErrorAction } from './on-error';
+export { FallbackOffthreadVideoProps, VideoProps } from './video/props';
 export { Audio, Video };

package/dist/media-player.d.ts

@@ -42,7 +42,7 @@ 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, onVideoFrameCallback, playing, }: {
+    constructor({ canvas, src, logLevel, sharedAudioContext, loop, trimBefore, trimAfter, playbackRate, globalPlaybackRate, audioStreamIndex, fps, debugOverlay, bufferState, isPremounting, isPostmounting, onVideoFrameCallback, playing }: {
         canvas: HTMLCanvasElement | OffscreenCanvas | null;
         src: string;
         logLevel: LogLevel;

package/dist/on-error.d.ts

@@ -0,0 +1,12 @@
+export type MediaErrorEvent = {
+    error: Error;
+};
+export type MediaErrorAction = 'fallback' | 'fail';
+export type MediaOnError = (error: Error) => MediaErrorAction | undefined;
+export declare const callOnErrorAndResolve: ({ onError, error, disallowFallback, isClientSideRendering, clientSideError, }: {
+    onError: MediaOnError | undefined;
+    error: Error;
+    clientSideError: Error;
+    disallowFallback: boolean;
+    isClientSideRendering: boolean;
+}) => [MediaErrorAction, Error];

package/dist/show-in-timeline.d.ts

@@ -1,8 +1,8 @@
-import type { _InternalTypes } from 'remotion';
+import type { LoopDisplay } from 'remotion';
 export declare const useLoopDisplay: ({ loop, mediaDurationInSeconds, playbackRate, trimAfter, trimBefore, }: {
     loop: boolean;
     mediaDurationInSeconds: number | null;
     trimAfter: number | undefined;
     trimBefore: number | undefined;
     playbackRate: number;
-}) => _InternalTypes["LoopDisplay"] | undefined;
+}) => LoopDisplay | undefined;

package/dist/use-media-in-timeline.d.ts

@@ -1,4 +1,4 @@
-import type { _InternalTypes } from 'remotion';
+import type { LoopDisplay } from 'remotion';
 import { type VolumeProp } from 'remotion';
 export declare const useMediaInTimeline: ({ volume, mediaVolume, src, mediaType, playbackRate, displayName, stack, showInTimeline, premountDisplay, postmountDisplay, loopDisplay, trimBefore, trimAfter, }: {
     volume: VolumeProp | undefined;
@@ -11,7 +11,7 @@ export declare const useMediaInTimeline: ({ volume, mediaVolume, src, mediaType,
     showInTimeline: boolean;
     premountDisplay: number | null;
     postmountDisplay: number | null;
-    loopDisplay: _InternalTypes["LoopDisplay"] | undefined;
+    loopDisplay: LoopDisplay | undefined;
     trimBefore: number | undefined;
     trimAfter: number | undefined;
 }) => {

package/dist/video/props.d.ts

@@ -1,4 +1,8 @@
 import type { LogLevel, LoopVolumeCurveBehavior, OnVideoFrame, VolumeProp } from 'remotion';
+import type { MediaOnError } from '../on-error';
+export type MediaErrorEvent = {
+    error: Error;
+};
 export type FallbackOffthreadVideoProps = {
     acceptableTimeShiftInSeconds?: number;
     transparent?: boolean;
@@ -39,6 +43,7 @@ type OptionalVideoProps = {
     showInTimeline: boolean;
     debugOverlay: boolean;
     headless: boolean;
+    onError: MediaOnError | undefined;
 };
 export type InnerVideoProps = MandatoryVideoProps & OuterVideoProps & OptionalVideoProps;
 export type VideoProps = MandatoryVideoProps & Partial<OuterVideoProps> & Partial<OptionalVideoProps>;

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

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { LogLevel, LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
+import { type MediaOnError } from '../on-error';
 import type { FallbackOffthreadVideoProps } from './props';
 type VideoForPreviewProps = {
     readonly src: string;
@@ -22,6 +23,7 @@ type VideoForPreviewProps = {
     readonly audioStreamIndex: number;
     readonly debugOverlay: boolean;
     readonly headless: boolean;
+    readonly onError: MediaOnError | undefined;
 };
 export declare const VideoForPreview: React.FC<VideoForPreviewProps>;
 export {};

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

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { LogLevel, LoopVolumeCurveBehavior, OnVideoFrame, VolumeProp } from 'remotion';
+import { type MediaOnError } from '../on-error';
 import type { FallbackOffthreadVideoProps } from './props';
 type InnerVideoProps = {
     readonly className: string | undefined;
@@ -23,6 +24,7 @@ type InnerVideoProps = {
     readonly trimBeforeValue: number | undefined;
     readonly trimAfterValue: number | undefined;
     readonly headless: boolean;
+    readonly onError: MediaOnError | undefined;
 };
 export declare const VideoForRendering: React.FC<InnerVideoProps>;
 export {};

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

@@ -1,6 +1,11 @@
 import type { WrappedCanvas } from 'mediabunny';
-import type { PrewarmedVideoIteratorCache } from '../prewarm-iterator-for-looping';
-export declare const createVideoIterator: (timeToSeek: number, cache: PrewarmedVideoIteratorCache) => {
+export declare const createVideoIterator: (timeToSeek: number, cache: {
+    prewarmIteratorForLooping: ({ timeToSeek }: {
+        timeToSeek: number;
+    }) => void;
+    makeIteratorOrUsePrewarmed: (timeToSeek: number) => AsyncGenerator<WrappedCanvas, void, unknown>;
+    destroy: () => void;
+}) => {
     destroy: () => void;
     getNext: () => Promise<IteratorResult<WrappedCanvas, void>>;
     isDestroyed: () => boolean;

package/dist/video-extraction/extract-frame-via-broadcast-channel.d.ts

@@ -1,4 +1,3 @@
-import { type LogLevel } from 'remotion';
 import type { PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
 export type ExtractFrameViaBroadcastChannelResult = {
     type: 'success';
@@ -21,7 +20,7 @@ export declare const extractFrameViaBroadcastChannel: ({ src, timeInSeconds, log
     timeInSeconds: number;
     durationInSeconds: number;
     playbackRate: number;
-    logLevel: LogLevel;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     includeAudio: boolean;
     includeVideo: boolean;
     isClientSideRendering: boolean;

package/dist/video-extraction/extract-frame.d.ts

@@ -2,7 +2,7 @@ import type { VideoSample } from 'mediabunny';
 import { type LogLevel } from 'remotion';
 type ExtractFrameResult = {
     type: 'success';
-    frame: VideoSample | null;
+    sample: VideoSample | null;
     durationInSeconds: number | null;
 } | {
     type: 'cannot-decode';
@@ -26,7 +26,5 @@ type ExtractFrameParams = {
     fps: number;
     maxCacheSize: number;
 };
-declare const extractFrameInternal: ({ src, timeInSeconds: unloopedTimeInSeconds, logLevel, loop, trimAfter, trimBefore, playbackRate, fps, maxCacheSize, }: ExtractFrameParams) => Promise<ExtractFrameResult>;
-type ExtractFrameReturnType = Awaited<ReturnType<typeof extractFrameInternal>>;
-export declare const extractFrame: (params: ExtractFrameParams) => Promise<ExtractFrameReturnType>;
+export declare const extractFrame: (params: ExtractFrameParams) => Promise<ExtractFrameResult>;
 export {};

package/dist/video-extraction/get-frames-since-keyframe.d.ts

@@ -1,15 +1,12 @@
-import type { EncodedPacket } from 'mediabunny';
-import { AudioSampleSink, EncodedPacketSink, VideoSampleSink } from 'mediabunny';
-import type { LogLevel } from 'remotion';
+import { AudioSampleSink, VideoSampleSink } from 'mediabunny';
 type VideoSinks = {
     sampleSink: VideoSampleSink;
-    packetSink: EncodedPacketSink;
 };
 type AudioSinks = {
     sampleSink: AudioSampleSink;
 };
 export type AudioSinkResult = AudioSinks | 'no-audio-track' | 'cannot-decode-audio' | 'unknown-container-format' | 'network-error';
-export type VideoSinkResult = VideoSinks | 'no-video-track' | 'cannot-decode' | 'unknown-container-format' | 'network-error';
+export type VideoSinkResult = VideoSinks | 'no-video-track' | 'cannot-decode' | 'cannot-decode-alpha' | 'unknown-container-format' | 'network-error';
 export declare const getSinks: (src: string) => Promise<{
     getVideo: () => Promise<VideoSinkResult>;
     getAudio: (index: number) => Promise<AudioSinkResult>;
@@ -21,11 +18,4 @@ export declare const getSinks: (src: string) => Promise<{
     getDuration: () => Promise<number>;
 }>;
 export type GetSink = Awaited<ReturnType<typeof getSinks>>;
-export declare const getFramesSinceKeyframe: ({ packetSink, videoSampleSink, startPacket, logLevel, src, }: {
-    packetSink: EncodedPacketSink;
-    videoSampleSink: VideoSampleSink;
-    startPacket: EncodedPacket;
-    logLevel: LogLevel;
-    src: string;
-}) => Promise<import("./keyframe-bank").KeyframeBank>;
 export {};

package/dist/video-extraction/keyframe-bank.d.ts

@@ -1,29 +1,31 @@
-import type { VideoSample } from 'mediabunny';
+import type { VideoSample, VideoSampleSink } from 'mediabunny';
 import { type LogLevel } from 'remotion';
 export type KeyframeBank = {
     src: string;
-    startTimestampInSeconds: number;
-    endTimestampInSeconds: number;
     getFrameFromTimestamp: (timestamp: number) => Promise<VideoSample | null>;
-    prepareForDeletion: (logLevel: LogLevel) => {
+    prepareForDeletion: (logLevel: LogLevel, reason: string) => {
         framesDeleted: number;
     };
-    deleteFramesBeforeTimestamp: ({ logLevel, timestampInSeconds, }: {
+    deleteFramesBeforeTimestamp: ({ logLevel, timestampInSeconds }: {
         timestampInSeconds: number;
         logLevel: LogLevel;
     }) => void;
     hasTimestampInSecond: (timestamp: number) => Promise<boolean>;
-    addFrame: (frame: VideoSample) => void;
+    addFrame: (frame: VideoSample, logLevel: LogLevel) => void;
     getOpenFrameCount: () => {
         size: number;
         timestamps: number[];
     };
     getLastUsed: () => number;
+    canSatisfyTimestamp: (timestamp: number) => boolean;
+    getRangeOfTimestamps: () => {
+        firstTimestamp: number;
+        lastTimestamp: number;
+    } | null;
 };
-export declare const makeKeyframeBank: ({ startTimestampInSeconds, endTimestampInSeconds, sampleIterator, logLevel: parentLogLevel, src, }: {
-    startTimestampInSeconds: number;
-    endTimestampInSeconds: number;
-    sampleIterator: AsyncGenerator<VideoSample, void, unknown>;
-    logLevel: LogLevel;
+export declare const makeKeyframeBank: ({ logLevel: parentLogLevel, src, videoSampleSink, requestedTimestamp, }: {
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     src: string;
-}) => KeyframeBank;
+    videoSampleSink: VideoSampleSink;
+    requestedTimestamp: number;
+}) => Promise<KeyframeBank>;

package/dist/video-extraction/keyframe-manager.d.ts

@@ -1,19 +1,17 @@
-import type { EncodedPacketSink, VideoSampleSink } from 'mediabunny';
-import { type LogLevel } from 'remotion';
+import type { VideoSampleSink } from 'mediabunny';
 import { type KeyframeBank } from './keyframe-bank';
 export declare const makeKeyframeManager: () => {
-    requestKeyframeBank: ({ packetSink, timestamp, videoSampleSink, src, logLevel, maxCacheSize, }: {
-        packetSink: EncodedPacketSink;
+    requestKeyframeBank: ({ timestamp, videoSampleSink, src, logLevel, maxCacheSize, }: {
         timestamp: number;
         videoSampleSink: VideoSampleSink;
         src: string;
-        logLevel: LogLevel;
+        logLevel: "error" | "info" | "trace" | "verbose" | "warn";
         maxCacheSize: number;
-    }) => Promise<KeyframeBank | "has-alpha" | null>;
-    getCacheStats: () => Promise<{
+    }) => Promise<KeyframeBank>;
+    getCacheStats: () => {
         count: number;
         totalSize: number;
-    }>;
-    clearAll: (logLevel: LogLevel) => Promise<void>;
+    };
+    clearAll: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
 };
 export type KeyframeManager = Awaited<ReturnType<typeof makeKeyframeManager>>;

package/dist/video-iterator-manager.d.ts

@@ -1,15 +1,14 @@
 import type { InputVideoTrack, WrappedCanvas } from 'mediabunny';
-import type { LogLevel } from 'remotion';
 import type { Nonce } from './nonce-manager';
 export declare const videoIteratorManager: ({ delayPlaybackHandleIfNotPremounting, canvas, context, drawDebugOverlay, logLevel, getOnVideoFrameCallback, videoTrack, getEndTime, getStartTime, getIsLooping, }: {
     videoTrack: InputVideoTrack;
     delayPlaybackHandleIfNotPremounting: () => {
         unblock: () => void;
     };
-    context: OffscreenCanvasRenderingContext2D | CanvasRenderingContext2D | null;
-    canvas: OffscreenCanvas | HTMLCanvasElement | null;
-    getOnVideoFrameCallback: () => null | ((frame: CanvasImageSource) => void);
-    logLevel: LogLevel;
+    context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D | null;
+    canvas: HTMLCanvasElement | OffscreenCanvas | null;
+    getOnVideoFrameCallback: () => ((frame: CanvasImageSource) => void) | null;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     drawDebugOverlay: () => void;
     getEndTime: () => number;
     getStartTime: () => number;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/media",
-	"version": "4.0.402",
+	"version": "4.0.404",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -12,30 +12,32 @@
 	"bugs": {
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
+	"type": "module",
 	"scripts": {
 		"if-node-18+": "node -e \"const [maj]=process.versions.node.split('.').map(Number); process.exit(maj>=18?0:1)\"",
 		"formatting": "prettier --experimental-cli src --check",
 		"lint": "eslint src",
-		"watch": "tsc -w",
+		"watch": "tsgo -w",
 		"test": "node src/test/execute.mjs",
-		"make": "tsc -d && bun --env-file=../.env.bundle bundle.ts"
+		"make": "tsgo && bun --env-file=../.env.bundle bundle.ts"
 	},
 	"dependencies": {
 		"mediabunny": "1.27.3",
-		"remotion": "4.0.402"
+		"remotion": "4.0.404"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
 		"react-dom": ">=16.8.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.402",
+		"@remotion/eslint-config-internal": "4.0.404",
 		"@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"
+		"webdriverio": "9.19.2",
+		"@typescript/native-preview": "7.0.0-dev.20260105.1"
 	},
 	"keywords": [],
 	"publishConfig": {
@@ -44,7 +46,6 @@
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
-			"require": "./dist/index.js",
 			"module": "./dist/esm/index.mjs",
 			"import": "./dist/esm/index.mjs"
 		},

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;
-};