@remotion/webcodecs 4.0.248 → 4.0.250

package/dist/auto-select-writer.js

@@ -11,6 +11,11 @@ const autoSelectWriter = async (writer, logLevel) => {
         return writer;
     }
     log_1.Log.verbose(logLevel, 'Determining best writer');
+    const hasNavigator = typeof navigator !== 'undefined';
+    if (!hasNavigator) {
+        log_1.Log.verbose(logLevel, 'No navigator API detected, using buffer writer');
+        return buffer_1.bufferWriter;
+    }
     // Check if we're offline using the navigator API
     const isOffline = !navigator.onLine;
     if (isOffline) {

package/dist/can-reencode-video-track.d.ts

@@ -1,6 +1,9 @@
 import type { VideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
-export declare const canReencodeVideoTrack: ({ videoCodec, track, }: {
+import type { ResizeOperation } from './resizing/mode';
+export declare const canReencodeVideoTrack: ({ videoCodec, track, resizeOperation, rotate, }: {
     videoCodec: ConvertMediaVideoCodec;
     track: VideoTrack;
+    resizeOperation: ResizeOperation | null;
+    rotate: number | null;
 }) => Promise<boolean>;

package/dist/can-reencode-video-track.js

@@ -1,13 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canReencodeVideoTrack = void 0;
+const rotation_1 = require("./rotation");
 const video_decoder_config_1 = require("./video-decoder-config");
 const video_encoder_config_1 = require("./video-encoder-config");
-const canReencodeVideoTrack = async ({ videoCodec, track, }) => {
-    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
-        codec: videoCodec,
+const canReencodeVideoTrack = async ({ videoCodec, track, resizeOperation, rotate, }) => {
+    const { height, width } = (0, rotation_1.calculateNewDimensionsFromRotateAndScale)({
         height: track.displayAspectHeight,
+        resizeOperation,
+        rotation: rotate !== null && rotate !== void 0 ? rotate : 0,
+        videoCodec,
         width: track.displayAspectWidth,
+    });
+    const videoEncoderConfig = await (0, video_encoder_config_1.getVideoEncoderConfig)({
+        codec: videoCodec,
+        height,
+        width,
         fps: track.fps,
     });
     const videoDecoderConfig = await (0, video_decoder_config_1.getVideoDecoderConfigWithHardwareAcceleration)(track);

package/dist/convert-media.d.ts

@@ -2,7 +2,7 @@
  * Copyright (c) 2025 Remotion AG
  * For licensing, see: https://remotion.dev/docs/webcodecs#license
  */
-import type { LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack } from '@remotion/media-parser';
+import type { AudioTrack, LogLevel, Options, ParseMediaDynamicOptions, ParseMediaFields, ParseMediaOptions, VideoTrack } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
@@ -30,10 +30,15 @@ export type ConvertMediaOnVideoFrame = (options: {
     frame: VideoFrame;
     track: VideoTrack;
 }) => Promise<VideoFrame> | VideoFrame;
-export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, progressIntervalInMs, rotate, apiKey, resize, ...more }: {
+export type ConvertMediaOnAudioData = (options: {
+    audioData: AudioData;
+    track: AudioTrack;
+}) => Promise<AudioData> | AudioData;
+export declare const convertMedia: <F extends Options<ParseMediaFields>>({ src, onVideoFrame, onAudioData, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel, writer, progressIntervalInMs, rotate, apiKey, resize, ...more }: {
     src: ParseMediaOptions<F>["src"];
     container: ConvertMediaContainer;
     onVideoFrame?: ConvertMediaOnVideoFrame;
+    onAudioData?: ConvertMediaOnAudioData;
     onProgress?: ConvertMediaOnProgress;
     videoCodec?: ConvertMediaVideoCodec;
     audioCodec?: ConvertMediaAudioCodec;

package/dist/convert-media.js

@@ -21,7 +21,7 @@ const on_video_track_1 = require("./on-video-track");
 const select_container_creator_1 = require("./select-container-creator");
 const send_telemetry_event_1 = require("./send-telemetry-event");
 const throttled_state_update_1 = require("./throttled-state-update");
-const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, progressIntervalInMs, rotate, apiKey, resize, ...more }) {
+const convertMedia = async function ({ src, onVideoFrame, onAudioData, onProgress: onProgressDoNotCallDirectly, audioCodec, container, videoCodec, signal: userPassedAbortSignal, onAudioTrack: userAudioResolver, onVideoTrack: userVideoResolver, reader, fields, logLevel = 'info', writer, progressIntervalInMs, rotate, apiKey, resize, ...more }) {
     var _a, _b;
     if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
         return Promise.reject(new error_cause_1.default('Aborted'));
@@ -106,6 +106,7 @@ const convertMedia = async function ({ src, onVideoFrame, onProgress: onProgress
         logLevel,
         outputContainer: container,
         progressTracker,
+        onAudioData: onAudioData !== null && onAudioData !== void 0 ? onAudioData : null,
     });
     (0, media_parser_1.parseMedia)({
         logLevel,

package/dist/create/matroska/matroska-utils.d.ts

@@ -19,7 +19,7 @@ export type EbmlParsedOrUint8Array<T extends Ebml> = {
     value: EbmlValueOrUint8Array<T>;
     minVintWidth: number | null;
 };
-export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 4 | 3 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 6 | 5 | 3 | 4;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;
 export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
 export type PossibleEbmlOrUint8Array = Prettify<{

package/dist/create/wav/create-wav.js

@@ -57,7 +57,7 @@ const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsPr
     };
     const addSample = async (chunk) => {
         var _a;
-        log_1.Log.verbose(logLevel, 'Adding sample', chunk);
+        log_1.Log.trace(logLevel, 'Adding sample', chunk);
         await w.write(chunk.data);
         onMillisecondsProgress((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
         onBytesProgress(w.getWrittenByteCount());

package/dist/default-on-video-track-handler.js

@@ -15,6 +15,8 @@ const defaultOnVideoTrackHandler = async ({ track, defaultVideoCodec, logLevel,
     const canReencode = await (0, can_reencode_video_track_1.canReencodeVideoTrack)({
         videoCodec: defaultVideoCodec,
         track,
+        resizeOperation,
+        rotate,
     });
     if (canReencode) {
         media_parser_1.MediaParserInternals.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);

package/dist/esm/index.mjs

@@ -1082,12 +1082,21 @@ var getVideoEncoderConfig = async ({
 // src/can-reencode-video-track.ts
 var canReencodeVideoTrack = async ({
   videoCodec,
-  track
+  track,
+  resizeOperation,
+  rotate
 }) => {
+  const { height, width } = calculateNewDimensionsFromRotateAndScale({
+    height: track.displayAspectHeight,
+    resizeOperation,
+    rotation: rotate ?? 0,
+    videoCodec,
+    width: track.displayAspectWidth
+  });
   const videoEncoderConfig = await getVideoEncoderConfig({
     codec: videoCodec,
-    height: track.displayAspectHeight,
-    width: track.displayAspectWidth,
+    height,
+    width,
     fps: track.fps
   });
   const videoDecoderConfig = await getVideoDecoderConfigWithHardwareAcceleration(track);
@@ -1103,6 +1112,11 @@ var autoSelectWriter = async (writer, logLevel) => {
     return writer;
   }
   Log.verbose(logLevel, "Determining best writer");
+  const hasNavigator = typeof navigator !== "undefined";
+  if (!hasNavigator) {
+    Log.verbose(logLevel, "No navigator API detected, using buffer writer");
+    return bufferWriter;
+  }
   const isOffline = !navigator.onLine;
   if (isOffline) {
     Log.verbose(logLevel, "Offline mode detected, using buffer writer");
@@ -1288,7 +1302,8 @@ var makeAudioTrackHandler = ({
   onAudioTrack,
   logLevel,
   outputContainer,
-  progressTracker
+  progressTracker,
+  onAudioData
 }) => async ({ track, container: inputContainer }) => {
   const canCopyTrack = canCopyAudioTrack({
     inputCodec: track.codecWithoutConfig,
@@ -1397,15 +1412,34 @@ var makeAudioTrackHandler = ({
     progressTracker
   });
   const audioDecoder = createAudioDecoder({
-    onFrame: async (frame) => {
-      await audioEncoder.encodeFrame(frame);
+    onFrame: async (audioData) => {
+      const newAudioData = onAudioData ? await onAudioData?.({ audioData, track }) : audioData;
+      if (newAudioData !== audioData) {
+        if (newAudioData.duration !== audioData.duration) {
+          throw new error_cause_default(`onAudioData returned a different duration than the input audio data. Original duration: ${audioData.duration}, new duration: ${newAudioData.duration}`);
+        }
+        if (newAudioData.numberOfChannels !== audioData.numberOfChannels) {
+          throw new error_cause_default(`onAudioData returned a different number of channels than the input audio data. Original channels: ${audioData.numberOfChannels}, new channels: ${newAudioData.numberOfChannels}`);
+        }
+        if (newAudioData.sampleRate !== audioData.sampleRate) {
+          throw new error_cause_default(`onAudioData returned a different sample rate than the input audio data. Original sample rate: ${audioData.sampleRate}, new sample rate: ${newAudioData.sampleRate}`);
+        }
+        if (newAudioData.format !== audioData.format) {
+          throw new error_cause_default(`onAudioData returned a different format than the input audio data. Original format: ${audioData.format}, new format: ${newAudioData.format}`);
+        }
+        if (newAudioData.timestamp !== audioData.timestamp) {
+          throw new error_cause_default(`onAudioData returned a different timestamp than the input audio data. Original timestamp: ${audioData.timestamp}, new timestamp: ${newAudioData.timestamp}`);
+        }
+        audioData.close();
+      }
+      await audioEncoder.encodeFrame(newAudioData);
       onMediaStateUpdate?.((prevState) => {
         return {
           ...prevState,
           decodedAudioFrames: prevState.decodedAudioFrames + 1
         };
       });
-      frame.close();
+      newAudioData.close();
     },
     onError(error) {
       abortConversion(new error_cause_default(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {
@@ -1454,7 +1488,9 @@ var defaultOnVideoTrackHandler = async ({
   }
   const canReencode = await canReencodeVideoTrack({
     videoCodec: defaultVideoCodec,
-    track
+    track,
+    resizeOperation,
+    rotate
   });
   if (canReencode) {
     MediaParserInternals4.Log.verbose(logLevel, `Track ${track.trackId} (video): Cannot copy, but re-enconde, therefore re-encoding`);
@@ -4134,7 +4170,7 @@ var createWav = async ({
     await w.updateDataAt(blockAlignPosition, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)));
   };
   const addSample = async (chunk) => {
-    Log.verbose(logLevel, "Adding sample", chunk);
+    Log.trace(logLevel, "Adding sample", chunk);
     await w.write(chunk.data);
     onMillisecondsProgress((chunk.timestamp + (chunk.duration ?? 0)) / 1000);
     onBytesProgress(w.getWrittenByteCount());
@@ -4273,6 +4309,7 @@ var throttledStateUpdate = ({
 var convertMedia = async function({
   src,
   onVideoFrame,
+  onAudioData,
   onProgress: onProgressDoNotCallDirectly,
   audioCodec,
   container,
@@ -4370,7 +4407,8 @@ var convertMedia = async function({
     onAudioTrack: userAudioResolver ?? null,
     logLevel,
     outputContainer: container,
-    progressTracker
+    progressTracker,
+    onAudioData: onAudioData ?? null
   });
   parseMedia({
     logLevel,

package/dist/esm/node-writer.mjs

@@ -0,0 +1,92 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// src/writers/node-writer.ts
+var { default: fs} = (() => ({}));
+var createContent = (filename) => {
+  return async () => {
+    const writPromise = Promise.resolve();
+    const remove = async () => {
+      await fs.promises.unlink(filename).catch(() => {
+      });
+    };
+    await remove();
+    const writeStream = await new Promise((resolve, reject) => {
+      fs.open(filename, "w", (err, fd) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(fd);
+      });
+    });
+    let written = 0;
+    const write = async (arr) => {
+      await new Promise((resolve, reject) => {
+        fs.write(writeStream, arr, (err) => {
+          if (err) {
+            reject(err);
+          }
+          resolve();
+        });
+      });
+      written += arr.byteLength;
+    };
+    const updateDataAt = async (position, data) => {
+      return new Promise((resolve, reject) => {
+        fs.write(writeStream, data, 0, data.length, position, (err) => {
+          if (err) {
+            reject(err);
+          }
+          resolve();
+        });
+      });
+    };
+    const writer = {
+      write: (arr) => {
+        writPromise.then(() => write(arr));
+        return writPromise;
+      },
+      updateDataAt: (position, data) => {
+        writPromise.then(() => updateDataAt(position, data));
+        return writPromise;
+      },
+      waitForFinish: async () => {
+        await writPromise;
+      },
+      getWrittenByteCount: () => written,
+      remove,
+      save: async () => {
+        try {
+          fs.closeSync(writeStream);
+          const file = await fs.promises.readFile(filename);
+          return new Blob([file]);
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+    };
+    return writer;
+  };
+};
+var nodeWriter = (path) => {
+  return { createContent: createContent(path) };
+};
+export {
+  nodeWriter
+};

package/dist/esm/node.mjs

@@ -0,0 +1,71 @@
+// src/writers/node.ts
+import fs from "node:fs";
+var createContent = (filename) => {
+  return async () => {
+    const writPromise = Promise.resolve();
+    const remove = async () => {
+      await fs.promises.unlink(filename).catch(() => {
+      });
+    };
+    await remove();
+    if (!fs.existsSync(filename)) {
+      fs.writeFileSync(filename, "");
+    }
+    const writeStream = fs.openSync(filename, "w");
+    let written = 0;
+    const write = async (data) => {
+      await new Promise((resolve, reject) => {
+        fs.write(writeStream, data, 0, data.length, undefined, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve();
+        });
+      });
+      written += data.byteLength;
+    };
+    const updateDataAt = (position, data) => {
+      return new Promise((resolve, reject) => {
+        fs.write(writeStream, data, 0, data.length, position, (err) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve();
+        });
+      });
+    };
+    const writer = {
+      write: (arr) => {
+        writPromise.then(() => write(arr));
+        return writPromise;
+      },
+      updateDataAt: (position, data) => {
+        writPromise.then(() => updateDataAt(position, data));
+        return writPromise;
+      },
+      waitForFinish: async () => {
+        await writPromise;
+      },
+      getWrittenByteCount: () => written,
+      remove,
+      save: async () => {
+        try {
+          fs.closeSync(writeStream);
+          const file = await fs.promises.readFile(filename);
+          return new Blob([file]);
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      }
+    };
+    return writer;
+  };
+};
+var nodeWriter = (path) => {
+  return { createContent: createContent(path) };
+};
+export {
+  nodeWriter
+};

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { canCopyAudioTrack } from './can-copy-audio-track';
 export { canCopyVideoTrack } from './can-copy-video-track';
 export { canReencodeAudioTrack } from './can-reencode-audio-track';
 export { canReencodeVideoTrack } from './can-reencode-video-track';
-export { convertMedia, ConvertMediaOnProgress, ConvertMediaOnVideoFrame, ConvertMediaProgress, ConvertMediaResult, } from './convert-media';
+export { convertMedia, ConvertMediaOnAudioData, ConvertMediaOnProgress, ConvertMediaOnVideoFrame, ConvertMediaProgress, ConvertMediaResult, } from './convert-media';
 export { defaultOnAudioTrackHandler } from './default-on-audio-track-handler';
 export { defaultOnVideoTrackHandler } from './default-on-video-track-handler';
 export { ConvertMediaAudioCodec, getAvailableAudioCodecs, } from './get-available-audio-codecs';

package/dist/on-audio-track.d.ts

@@ -1,4 +1,5 @@
 import { type LogLevel, type OnAudioTrack } from '@remotion/media-parser';
+import type { ConvertMediaOnAudioData } from './convert-media';
 import type { MediaFn } from './create/media-fn';
 import type { ProgressTracker } from './create/progress-tracker';
 import Error from './error-cause';
@@ -6,7 +7,7 @@ import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
 import type { ConvertMediaContainer } from './get-available-containers';
 import type { ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import type { ConvertMediaProgressFn } from './throttled-state-update';
-export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, progressTracker, }: {
+export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, progressTracker, onAudioData, }: {
     state: MediaFn;
     defaultAudioCodec: ConvertMediaAudioCodec | null;
     controller: AbortController;
@@ -16,4 +17,5 @@ export declare const makeAudioTrackHandler: ({ state, defaultAudioCodec: audioCo
     logLevel: LogLevel;
     outputContainer: ConvertMediaContainer;
     progressTracker: ProgressTracker;
+    onAudioData: ConvertMediaOnAudioData | null;
 }) => OnAudioTrack;

package/dist/on-audio-track.js

@@ -15,7 +15,7 @@ const default_on_audio_track_handler_1 = require("./default-on-audio-track-handl
 const error_cause_1 = __importDefault(require("./error-cause"));
 const get_default_audio_codec_1 = require("./get-default-audio-codec");
 const log_1 = require("./log");
-const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, progressTracker, }) => async ({ track, container: inputContainer }) => {
+const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controller, abortConversion, onMediaStateUpdate, onAudioTrack, logLevel, outputContainer, progressTracker, onAudioData, }) => async ({ track, container: inputContainer }) => {
     const canCopyTrack = (0, can_copy_audio_track_1.canCopyAudioTrack)({
         inputCodec: track.codecWithoutConfig,
         outputContainer,
@@ -131,15 +131,36 @@ const makeAudioTrackHandler = ({ state, defaultAudioCodec: audioCodec, controlle
         progressTracker,
     });
     const audioDecoder = (0, audio_decoder_1.createAudioDecoder)({
-        onFrame: async (frame) => {
-            await audioEncoder.encodeFrame(frame);
+        onFrame: async (audioData) => {
+            const newAudioData = onAudioData
+                ? await (onAudioData === null || onAudioData === void 0 ? void 0 : onAudioData({ audioData, track }))
+                : audioData;
+            if (newAudioData !== audioData) {
+                if (newAudioData.duration !== audioData.duration) {
+                    throw new error_cause_1.default(`onAudioData returned a different duration than the input audio data. Original duration: ${audioData.duration}, new duration: ${newAudioData.duration}`);
+                }
+                if (newAudioData.numberOfChannels !== audioData.numberOfChannels) {
+                    throw new error_cause_1.default(`onAudioData returned a different number of channels than the input audio data. Original channels: ${audioData.numberOfChannels}, new channels: ${newAudioData.numberOfChannels}`);
+                }
+                if (newAudioData.sampleRate !== audioData.sampleRate) {
+                    throw new error_cause_1.default(`onAudioData returned a different sample rate than the input audio data. Original sample rate: ${audioData.sampleRate}, new sample rate: ${newAudioData.sampleRate}`);
+                }
+                if (newAudioData.format !== audioData.format) {
+                    throw new error_cause_1.default(`onAudioData returned a different format than the input audio data. Original format: ${audioData.format}, new format: ${newAudioData.format}`);
+                }
+                if (newAudioData.timestamp !== audioData.timestamp) {
+                    throw new error_cause_1.default(`onAudioData returned a different timestamp than the input audio data. Original timestamp: ${audioData.timestamp}, new timestamp: ${newAudioData.timestamp}`);
+                }
+                audioData.close();
+            }
+            await audioEncoder.encodeFrame(newAudioData);
             onMediaStateUpdate === null || onMediaStateUpdate === void 0 ? void 0 : onMediaStateUpdate((prevState) => {
                 return {
                     ...prevState,
                     decodedAudioFrames: prevState.decodedAudioFrames + 1,
                 };
             });
-            frame.close();
+            newAudioData.close();
         },
         onError(error) {
             abortConversion(new error_cause_1.default(`Audio decoder of track ${track.trackId} failed. Config: ${JSON.stringify(audioDecoderConfig)} (see .cause of this error)`, {

package/dist/select-container-creator.d.ts

@@ -1,2 +1,2 @@
 import type { ConvertMediaContainer } from './get-available-containers';
-export declare const selectContainerCreator: (container: ConvertMediaContainer) => ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;
+export declare const selectContainerCreator: (container: ConvertMediaContainer) => ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }: import("./create/media-fn").MediaFnGeneratorInput) => Promise<import("./create/media-fn").MediaFn>;

package/dist/test/create-matroska.test.js

@@ -12,6 +12,8 @@ const state = media_parser_1.MediaParserInternals.makeParserState({
     onAudioTrack: null,
     onVideoTrack: null,
     supportsContentRange: true,
+    contentLength: null,
+    logLevel: 'info',
 });
 (0, bun_test_1.test)('Should make Matroska header that is same as input', async () => {
     const headerOutput = (0, matroska_utils_1.makeMatroskaBytes)({

package/dist/test/remux-serverside.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/remux-serverside.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_1 = require("@remotion/media-parser/node");
+const bun_test_1 = require("bun:test");
+const convert_media_1 = require("../convert-media");
+(0, bun_test_1.test)('should be able to remux on server side', async () => {
+    await (0, convert_media_1.convertMedia)({
+        src: '/Users/jonathanburger/Downloads/odaje_glitch.mov',
+        reader: node_1.nodeReader,
+        container: 'mp4',
+    });
+});

package/dist/test/remux-serverside.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/remux-serverside.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const example_videos_1 = require("@remotion/example-videos");
+const node_1 = require("@remotion/media-parser/node");
+const bun_test_1 = require("bun:test");
+const node_fs_1 = require("node:fs");
+const convert_media_1 = require("../convert-media");
+const node_2 = require("../writers/node");
+(0, bun_test_1.test)('should be able to remux server side', async () => {
+    const { save } = await (0, convert_media_1.convertMedia)({
+        src: example_videos_1.exampleVideos.bigBuckBunny,
+        reader: node_1.nodeReader,
+        container: 'mp4',
+        writer: (0, node_2.nodeWriter)('outputbun.mp4'),
+    });
+    const data = await save();
+    (0, bun_test_1.expect)(data.size).toBe(15306323);
+    (0, node_fs_1.unlinkSync)('outputbun.mp4');
+});

package/dist/test/stsd.test.js

@@ -47,9 +47,9 @@ const bun_test_1 = require("bun:test");
             getIterator: () => null,
             fields: {},
             supportsContentRange: true,
+            contentLength: null,
+            logLevel: 'info',
         }),
-        signal: null,
-        fields: {},
     });
     (0, bun_test_1.expect)(parsed).toEqual({
         offset: 0,
@@ -214,10 +214,9 @@ const bun_test_1 = require("bun:test");
                 structure: true,
             },
             supportsContentRange: true,
+            contentLength: null,
+            logLevel: 'info',
         }),
-        signal: null,
-        logLevel: 'info',
-        fields: {},
     });
     (0, bun_test_1.expect)(parsed.sample).toEqual({
         size: 158,

package/dist/writers/fs.d.ts

@@ -0,0 +1,4 @@
+import type { CreateContent } from './writer';
+export declare const fsWriter: (path: string) => {
+    createContent: CreateContent;
+};

package/dist/writers/fs.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsWriter = void 0;
+const fs_1 = __importDefault(require("fs"));
+const createContent = (filename) => {
+    return async () => {
+        let writPromise = Promise.resolve();
+        const remove = () => {
+            try {
+                fs_1.default.unlinkSync(filename);
+            }
+            catch (_a) { }
+            return Promise.resolve();
+        };
+        await remove();
+        if (!fs_1.default.existsSync(filename)) {
+            fs_1.default.writeFileSync(filename, '');
+        }
+        const writeStream = fs_1.default.openSync(filename, 'w');
+        let written = 0;
+        const write = async (data) => {
+            await new Promise((resolve, reject) => {
+                fs_1.default.write(writeStream, data, 0, data.byteLength, written, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            written += data.byteLength;
+        };
+        const updateDataAt = (position, data) => {
+            return new Promise((resolve, reject) => {
+                fs_1.default.write(writeStream, data, 0, data.byteLength, position, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        };
+        const writer = {
+            write: (arr) => {
+                writPromise = writPromise.then(() => write(arr));
+                return writPromise;
+            },
+            updateDataAt: (position, data) => {
+                writPromise = writPromise.then(() => updateDataAt(position, data));
+                return writPromise;
+            },
+            waitForFinish: async () => {
+                await writPromise;
+            },
+            getWrittenByteCount: () => written,
+            remove,
+            save: async () => {
+                try {
+                    fs_1.default.closeSync(writeStream);
+                    const file = await fs_1.default.promises.readFile(filename);
+                    return new Blob([file]);
+                }
+                catch (e) {
+                    return Promise.reject(e);
+                }
+            },
+        };
+        return writer;
+    };
+};
+const fsWriter = (path) => {
+    return { createContent: createContent(path) };
+};
+exports.fsWriter = fsWriter;

package/dist/writers/node-writer.d.ts

@@ -0,0 +1,4 @@
+import type { CreateContent } from './writer';
+export declare const nodeWriter: (path: string) => {
+    createContent: CreateContent;
+};

package/dist/writers/node-writer.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeWriter = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const createContent = (filename) => {
+    return async () => {
+        const writPromise = Promise.resolve();
+        const remove = async () => {
+            await node_fs_1.default.promises.unlink(filename).catch(() => { });
+        };
+        await remove();
+        const writeStream = await new Promise((resolve, reject) => {
+            node_fs_1.default.open(filename, 'w', (err, fd) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve(fd);
+            });
+        });
+        let written = 0;
+        const write = async (arr) => {
+            await new Promise((resolve, reject) => {
+                node_fs_1.default.write(writeStream, arr, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    resolve();
+                });
+            });
+            written += arr.byteLength;
+        };
+        const updateDataAt = async (position, data) => {
+            return new Promise((resolve, reject) => {
+                node_fs_1.default.write(writeStream, data, 0, data.length, position, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    resolve();
+                });
+            });
+        };
+        const writer = {
+            write: (arr) => {
+                writPromise.then(() => write(arr));
+                return writPromise;
+            },
+            updateDataAt: (position, data) => {
+                writPromise.then(() => updateDataAt(position, data));
+                return writPromise;
+            },
+            waitForFinish: async () => {
+                await writPromise;
+            },
+            getWrittenByteCount: () => written,
+            remove,
+            save: async () => {
+                try {
+                    node_fs_1.default.closeSync(writeStream);
+                    const file = await node_fs_1.default.promises.readFile(filename);
+                    return new Blob([file]);
+                }
+                catch (e) {
+                    return Promise.reject(e);
+                }
+            },
+        };
+        return writer;
+    };
+};
+const nodeWriter = (path) => {
+    return { createContent: createContent(path) };
+};
+exports.nodeWriter = nodeWriter;

package/dist/writers/node.d.ts

@@ -0,0 +1,4 @@
+import type { CreateContent } from './writer';
+export declare const nodeWriter: (path: string) => {
+    createContent: CreateContent;
+};

package/dist/writers/node.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeWriter = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const createContent = (filename) => {
+    return async () => {
+        const writPromise = Promise.resolve();
+        const remove = async () => {
+            await node_fs_1.default.promises.unlink(filename).catch(() => { });
+        };
+        await remove();
+        if (!node_fs_1.default.existsSync(filename)) {
+            node_fs_1.default.writeFileSync(filename, '');
+        }
+        const writeStream = node_fs_1.default.openSync(filename, 'w');
+        let written = 0;
+        const write = async (data) => {
+            await new Promise((resolve, reject) => {
+                node_fs_1.default.write(writeStream, data, 0, data.length, undefined, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            written += data.byteLength;
+        };
+        const updateDataAt = (position, data) => {
+            return new Promise((resolve, reject) => {
+                node_fs_1.default.write(writeStream, data, 0, data.length, position, (err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        };
+        const writer = {
+            write: (arr) => {
+                writPromise.then(() => write(arr));
+                return writPromise;
+            },
+            updateDataAt: (position, data) => {
+                writPromise.then(() => updateDataAt(position, data));
+                return writPromise;
+            },
+            waitForFinish: async () => {
+                await writPromise;
+            },
+            getWrittenByteCount: () => written,
+            remove,
+            save: async () => {
+                try {
+                    node_fs_1.default.closeSync(writeStream);
+                    const file = await node_fs_1.default.promises.readFile(filename);
+                    return new Blob([file]);
+                }
+                catch (e) {
+                    return Promise.reject(e);
+                }
+            },
+        };
+        return writer;
+    };
+};
+const nodeWriter = (path) => {
+    return { createContent: createContent(path) };
+};
+exports.nodeWriter = nodeWriter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.248",
+  "version": "4.0.250",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -17,15 +17,15 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "Remotion License (See https://remotion.dev/docs/webcodecs#license)",
   "dependencies": {
-    "@remotion/media-parser": "4.0.248",
-    "@remotion/licensing": "4.0.248"
+    "@remotion/media-parser": "4.0.250",
+    "@remotion/licensing": "4.0.250"
   },
   "peerDependencies": {},
   "devDependencies": {
     "@types/dom-webcodecs": "0.1.11",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.248",
-    "@remotion/eslint-config-internal": "4.0.248"
+    "@remotion/example-videos": "4.0.250",
+    "@remotion/eslint-config-internal": "4.0.250"
   },
   "keywords": [],
   "publishConfig": {
@@ -50,6 +50,12 @@
       "module": "./dist/esm/buffer.mjs",
       "import": "./dist/esm/buffer.mjs"
     },
+    "./node": {
+      "types": "./dist/writers/node.d.ts",
+      "require": "./dist/writers/node.js",
+      "module": "./dist/esm/node.mjs",
+      "import": "./dist/esm/node.mjs"
+    },
     "./package.json": "./package.json"
   },
   "typesVersions": {
@@ -57,6 +63,9 @@
       "web-fs": [
         "dist/writers/web-fs.d.ts"
       ],
+      "node": [
+        "dist/writers/node.d.ts"
+      ],
       "buffer": [
         "dist/writers/buffer.d.ts"
       ]