@remotion/serverless 4.0.514 → 4.0.515

package/dist/cancellation-polling.d.ts

@@ -0,0 +1,11 @@
+import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless-client';
+export declare const startCancellationPolling: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ bucketName, renderId, region, providerSpecifics, forcePathStyle, intervalInMilliseconds, logLevel, onCancelled, }: {
+    bucketName: string;
+    renderId: string;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+    intervalInMilliseconds: number;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    onCancelled: () => void;
+}) => () => void;

package/dist/cancellation-polling.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCancellationPolling = void 0;
+const renderer_1 = require("@remotion/renderer");
+const serverless_client_1 = require("@remotion/serverless-client");
+const isMissingCancellationSignalError = (err) => {
+    const error = err;
+    return (error.name === 'NoSuchKey' ||
+        error.name === 'NotFound' ||
+        error.Code === 'NoSuchKey' ||
+        error.code === 'NoSuchKey');
+};
+const startCancellationPolling = ({ bucketName, renderId, region, providerSpecifics, forcePathStyle, intervalInMilliseconds, logLevel, onCancelled, }) => {
+    let stopped = false;
+    let timeout = null;
+    const poll = async () => {
+        try {
+            await providerSpecifics.headFile({
+                bucketName,
+                key: (0, serverless_client_1.cancellationKey)(renderId),
+                region,
+                customCredentials: null,
+                forcePathStyle,
+                requestHandler: null,
+            });
+            if (!stopped) {
+                stopped = true;
+                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Render cancellation signal received.');
+                onCancelled();
+            }
+        }
+        catch (err) {
+            if (!isMissingCancellationSignalError(err)) {
+                renderer_1.RenderInternals.Log.warn({ indent: false, logLevel }, 'Could not check for a render cancellation signal. Retrying.', err);
+            }
+        }
+        if (!stopped) {
+            timeout = setTimeout(poll, intervalInMilliseconds);
+        }
+    };
+    poll().catch((err) => {
+        renderer_1.RenderInternals.Log.warn({ indent: false, logLevel }, 'Cancellation polling stopped unexpectedly.', err);
+    });
+    return () => {
+        stopped = true;
+        if (timeout !== null) {
+            clearTimeout(timeout);
+        }
+    };
+};
+exports.startCancellationPolling = startCancellationPolling;

package/dist/handlers/launch.js

@@ -164,8 +164,9 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
     // Throttling a bit, allowing more progress if there is lower concurrency.
     const progressEveryNthFrame = Math.ceil(chunks.length / 15);
     const lambdaPayloads = chunks.map((chunkPayload) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const payload = {
+            enableCancellation: (_a = params.enableCancellation) !== null && _a !== void 0 ? _a : false,
             type: serverless_client_2.ServerlessRoutines.renderer,
             frameRange: chunkPayload,
             serveUrl: params.serveUrl,
@@ -186,13 +187,13 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
             pixelFormat: params.pixelFormat,
             proResProfile: params.proResProfile,
             x264Preset: params.x264Preset,
-            gopSize: (_a = params.gopSize) !== null && _a !== void 0 ? _a : null,
+            gopSize: (_b = params.gopSize) !== null && _b !== void 0 ? _b : null,
             jpegQuality: params.jpegQuality,
             privacy: params.privacy,
-            logLevel: (_b = params.logLevel) !== null && _b !== void 0 ? _b : 'info',
+            logLevel: (_c = params.logLevel) !== null && _c !== void 0 ? _c : 'info',
             attempt: 1,
             timeoutInMilliseconds: params.timeoutInMilliseconds,
-            chromiumOptions: (_c = params.chromiumOptions) !== null && _c !== void 0 ? _c : {},
+            chromiumOptions: (_d = params.chromiumOptions) !== null && _d !== void 0 ? _d : {},
             scale: params.scale,
             everyNthFrame: params.everyNthFrame,
             concurrencyPerLambda: params.concurrencyPerFunction,
@@ -428,7 +429,7 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
     return postRenderData;
 };
 const launchHandler = async ({ params, options, providerSpecifics, insideFunctionSpecifics, }) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     if (params.type !== serverless_client_2.ServerlessRoutines.launch) {
         throw new Error('Expected launch type');
     }
@@ -452,6 +453,25 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
         cleanupTasks.length = 0;
         return prom;
     };
+    const cancelOtherRenderers = async () => {
+        if (!params.enableCancellation) {
+            return;
+        }
+        try {
+            await (0, serverless_client_2.writeCancellationSignal)({
+                bucketName: params.bucketName,
+                renderId: params.renderId,
+                region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+                expectedBucketOwner: options.expectedBucketOwner,
+                providerSpecifics,
+                forcePathStyle: params.forcePathStyle,
+                requestHandler: null,
+            });
+        }
+        catch (err) {
+            renderer_1.RenderInternals.Log.warn({ indent: false, logLevel: params.logLevel }, 'Could not signal other renderers to stop.', err);
+        }
+    };
     const onTimeout = async () => {
         var _a;
         renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Function is about to time out. Can not finish render.');
@@ -461,6 +481,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
             globalThis._dumpUnreleasedBuffers.emit('dump-unreleased-buffers');
         }
         runCleanupTasks();
+        await cancelOtherRenderers();
         if (!params.webhook) {
             renderer_1.RenderInternals.Log.verbose({
                 indent: false,
@@ -522,6 +543,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
     const webhookDueToTimeout = setTimeout(onTimeout, Math.max(options.getRemainingTimeInMillis() - 1000, 1000));
     renderer_1.RenderInternals.Log.info(logOptions, `Function has ${Math.max(options.getRemainingTimeInMillis() - 1000, 1000)} before it times out`);
     const overallProgress = (0, overall_render_progress_1.makeOverallRenderProgress)({
+        cancellationEnabled: (_a = params.enableCancellation) !== null && _a !== void 0 ? _a : false,
         renderId: params.renderId,
         bucketName: params.bucketName,
         expectedBucketOwner: options.expectedBucketOwner,
@@ -545,10 +567,10 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
         });
         clearTimeout(webhookDueToTimeout);
         (0, send_telemetry_event_1.sendTelemetryEvent)({
-            licenseKey: (_a = params.licenseKey) !== null && _a !== void 0 ? _a : null,
+            licenseKey: (_b = params.licenseKey) !== null && _b !== void 0 ? _b : null,
             logLevel: params.logLevel,
             isStill: false,
-            isProduction: (_b = params.isProduction) !== null && _b !== void 0 ? _b : true,
+            isProduction: (_c = params.isProduction) !== null && _c !== void 0 ? _c : true,
         });
         if (!params.webhook || webhookInvoked) {
             return;
@@ -563,7 +585,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
                         renderId: params.renderId,
                         expectedBucketOwner: options.expectedBucketOwner,
                         bucketName: params.bucketName,
-                        customData: (_c = params.webhook.customData) !== null && _c !== void 0 ? _c : null,
+                        customData: (_d = params.webhook.customData) !== null && _d !== void 0 ? _d : null,
                         outputUrl: postRenderData.outputFile,
                         lambdaErrors: postRenderData.errors,
                         outputFile: postRenderData.outputFile,
@@ -602,6 +624,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
         if (process.env.NODE_ENV === 'test') {
             throw err;
         }
+        await cancelOtherRenderers();
         renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Error occurred', err);
         overallProgress.addErrorWithoutUpload({
             chunk: null,
@@ -631,7 +654,7 @@ const launchHandler = async ({ params, options, providerSpecifics, insideFunctio
                             renderId: params.renderId,
                             expectedBucketOwner: options.expectedBucketOwner,
                             bucketName: params.bucketName,
-                            customData: (_d = params.webhook.customData) !== null && _d !== void 0 ? _d : null,
+                            customData: (_e = params.webhook.customData) !== null && _e !== void 0 ? _e : null,
                             errors: [err].map((e) => ({
                                 message: e.message,
                                 name: e.name,

package/dist/handlers/renderer.js

@@ -9,11 +9,12 @@ const node_path_1 = __importDefault(require("node:path"));
 const renderer_1 = require("@remotion/renderer");
 const pure_1 = require("@remotion/renderer/pure");
 const serverless_client_1 = require("@remotion/serverless-client");
+const cancellation_polling_1 = require("../cancellation-polling");
 const get_tmp_dir_1 = require("../get-tmp-dir");
 const leak_detection_1 = require("../leak-detection");
 const on_downloads_helpers_1 = require("../on-downloads-helpers");
 const why_is_node_running_1 = require("../why-is-node-running");
-const renderHandler = async ({ params, options, logs, onStream, providerSpecifics, insideFunctionSpecifics, onBrowserInstance, onMediaFiles, }) => {
+const renderHandler = async ({ params, options, logs, onStream, providerSpecifics, insideFunctionSpecifics, onBrowserInstance, onMediaFiles, cancelSignal, }) => {
     if (params.type !== serverless_client_1.ServerlessRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -209,7 +210,7 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
             audioCodec,
             preferLossless: params.preferLossless,
             browserExecutable: providerSpecifics.getChromiumPath(),
-            cancelSignal: undefined,
+            cancelSignal: cancelSignal !== null && cancelSignal !== void 0 ? cancelSignal : undefined,
             disallowParallelEncoding: false,
             ffmpegOverride: ({ args }) => args,
             indent: false,
@@ -302,6 +303,23 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
     const leakDetection = (0, why_is_node_running_1.enableNodeIntrospection)(ENABLE_SLOW_LEAK_DETECTION);
     let shouldKeepBrowserOpen = true;
     let instance;
+    let cancellationRequested = false;
+    const { cancel, cancelSignal } = (0, renderer_1.makeCancelSignal)();
+    const stopCancellationPolling = params.enableCancellation
+        ? (0, cancellation_polling_1.startCancellationPolling)({
+            bucketName: params.bucketName,
+            renderId: params.renderId,
+            region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+            providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+            intervalInMilliseconds: 1000,
+            logLevel: params.logLevel,
+            onCancelled: () => {
+                cancellationRequested = true;
+                cancel();
+            },
+        })
+        : () => undefined;
     try {
         await renderHandler({
             params,
@@ -314,6 +332,7 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
                 instance = browserInstance;
             },
             onMediaFiles,
+            cancelSignal: params.enableCancellation ? cancelSignal : null,
         });
     }
     catch (err) {
@@ -328,7 +347,7 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
         if (isRetryableError) {
             shouldKeepBrowserOpen = false;
         }
-        const shouldNotRetry = err.name === 'CancelledError';
+        const shouldNotRetry = cancellationRequested || err.name === 'CancelledError';
         const shouldRetry = isRetryableError && params.retriesLeft > 0 && !shouldNotRetry;
         renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, `Error occurred (will retry = ${String(shouldRetry)})`);
         renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, err.stack);
@@ -354,6 +373,7 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
         });
     }
     finally {
+        stopCancellationPolling();
         if (shouldKeepBrowserOpen && instance) {
             insideFunctionSpecifics.forgetBrowserEventLoop({
                 logLevel: params.logLevel,

package/dist/handlers/start.js

@@ -5,7 +5,7 @@ const serverless_client_1 = require("@remotion/serverless-client");
 const overall_render_progress_1 = require("../overall-render-progress");
 const check_version_mismatch_1 = require("./check-version-mismatch");
 const startHandler = async ({ params, options, providerSpecifics, insideFunctionSpecifics, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     if (params.type !== serverless_client_1.ServerlessRoutines.start) {
         throw new TypeError('Expected type start');
     }
@@ -35,7 +35,7 @@ const startHandler = async ({ params, options, providerSpecifics, insideFunction
         bucketName,
         downloadBehavior: null,
         region,
-        body: JSON.stringify((0, overall_render_progress_1.makeInitialOverallRenderProgress)(options.timeoutInMilliseconds + Date.now())),
+        body: JSON.stringify((0, overall_render_progress_1.makeInitialOverallRenderProgress)(options.timeoutInMilliseconds + Date.now(), (_b = params.enableCancellation) !== null && _b !== void 0 ? _b : false)),
         expectedBucketOwner: options.expectedBucketOwner,
         key: (0, serverless_client_1.overallProgressKey)(options.renderId),
         privacy: 'private',
@@ -45,6 +45,7 @@ const startHandler = async ({ params, options, providerSpecifics, insideFunction
         requestHandler: null,
     });
     const payload = {
+        enableCancellation: (_c = params.enableCancellation) !== null && _c !== void 0 ? _c : false,
         type: serverless_client_1.ServerlessRoutines.launch,
         framesPerFunction: params.framesPerLambda,
         concurrency: params.concurrency,
@@ -55,12 +56,14 @@ const startHandler = async ({ params, options, providerSpecifics, insideFunction
         renderId: options.renderId,
         codec: params.codec,
         imageFormat: params.imageFormat,
-        crf: (_b = params.crf) !== null && _b !== void 0 ? _b : null,
+        crf: (_d = params.crf) !== null && _d !== void 0 ? _d : null,
         envVariables: params.envVariables,
-        pixelFormat: (_c = params.pixelFormat) !== null && _c !== void 0 ? _c : null,
-        proResProfile: (_d = params.proResProfile) !== null && _d !== void 0 ? _d : null,
-        x264Preset: params.x264Preset,
-        gopSize: (_e = params.gopSize) !== null && _e !== void 0 ? _e : null,
+        pixelFormat: (_e = params.pixelFormat) !== null && _e !== void 0 ? _e : null,
+        proResProfile: (_f = params.proResProfile) !== null && _f !== void 0 ? _f : null,
+        x264Preset: (_g = params.x264Preset) !== null && _g !== void 0 ? _g : (params.codec === 'h264'
+            ? insideFunctionSpecifics.defaultX264Preset
+            : null),
+        gopSize: (_h = params.gopSize) !== null && _h !== void 0 ? _h : null,
         jpegQuality: params.jpegQuality,
         maxRetries: params.maxRetries,
         privacy: params.privacy,
@@ -83,8 +86,8 @@ const startHandler = async ({ params, options, providerSpecifics, insideFunction
         encodingMaxRate: params.encodingMaxRate,
         forceHeight: params.forceHeight,
         forceWidth: params.forceWidth,
-        forceFps: (_f = params.forceFps) !== null && _f !== void 0 ? _f : null,
-        forceDurationInFrames: (_g = params.forceDurationInFrames) !== null && _g !== void 0 ? _g : null,
+        forceFps: (_j = params.forceFps) !== null && _j !== void 0 ? _j : null,
+        forceDurationInFrames: (_k = params.forceDurationInFrames) !== null && _k !== void 0 ? _k : null,
         rendererFunctionName: params.rendererFunctionName,
         audioCodec: params.audioCodec,
         offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
@@ -97,8 +100,8 @@ const startHandler = async ({ params, options, providerSpecifics, insideFunction
         offthreadVideoThreads: params.offthreadVideoThreads,
         storageClass: params.storageClass,
         mediaCacheSizeInBytes: params.mediaCacheSizeInBytes,
-        isProduction: (_h = params.isProduction) !== null && _h !== void 0 ? _h : true,
-        sampleRate: (_j = params.sampleRate) !== null && _j !== void 0 ? _j : 48000,
+        isProduction: (_l = params.isProduction) !== null && _l !== void 0 ? _l : true,
+        sampleRate: (_m = params.sampleRate) !== null && _m !== void 0 ? _m : 48000,
     };
     await providerSpecifics.callFunctionAsync({
         functionName: insideFunctionSpecifics.getCurrentFunctionName(),

package/dist/handlers/still.js

@@ -153,7 +153,7 @@ const innerStillHandler = async ({ params, expectedBucketOwner, renderId, onStre
         },
         scale: params.scale,
     };
-    const still = (0, overall_render_progress_1.makeInitialOverallRenderProgress)(timeoutInMilliseconds);
+    const still = (0, overall_render_progress_1.makeInitialOverallRenderProgress)(timeoutInMilliseconds, false);
     still.renderMetadata = renderMetadata;
     await providerSpecifics.writeFile({
         bucketName,

package/dist/overall-render-progress.d.ts

@@ -21,8 +21,8 @@ export type OverallProgressHelper<Provider extends CloudProvider> = {
     addReceivedArtifact: (asset: ReceivedArtifact<Provider>) => void;
     getReceivedArtifacts: () => ReceivedArtifact<Provider>[];
 };
-export declare const makeInitialOverallRenderProgress: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>(timeoutTimestamp: number) => OverallRenderProgress<Provider>;
-export declare const makeOverallRenderProgress: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, }: {
+export declare const makeInitialOverallRenderProgress: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>(timeoutTimestamp: number, cancellationEnabled: boolean) => OverallRenderProgress<Provider>;
+export declare const makeOverallRenderProgress: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, cancellationEnabled, }: {
     renderId: string;
     bucketName: string;
     expectedBucketOwner: string;
@@ -31,4 +31,5 @@ export declare const makeOverallRenderProgress: <Provider extends CloudProvider<
     logLevel: "error" | "info" | "trace" | "verbose" | "warn";
     providerSpecifics: ProviderSpecifics<Provider>;
     forcePathStyle: boolean;
+    cancellationEnabled: boolean;
 }) => OverallProgressHelper<Provider>;

package/dist/overall-render-progress.js

@@ -9,8 +9,9 @@ const wait = (duration) => {
         setTimeout(resolve, duration);
     });
 };
-const makeInitialOverallRenderProgress = (timeoutTimestamp) => {
+const makeInitialOverallRenderProgress = (timeoutTimestamp, cancellationEnabled) => {
     return {
+        cancellationEnabled,
         chunks: [],
         framesRendered: 0,
         framesEncoded: 0,
@@ -33,11 +34,11 @@ const makeInitialOverallRenderProgress = (timeoutTimestamp) => {
     };
 };
 exports.makeInitialOverallRenderProgress = makeInitialOverallRenderProgress;
-const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, }) => {
+const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, cancellationEnabled, }) => {
     let framesRendered = [];
     let framesEncoded = [];
     let lambdasInvoked = [];
-    const renderProgress = (0, exports.makeInitialOverallRenderProgress)(timeoutTimestamp);
+    const renderProgress = (0, exports.makeInitialOverallRenderProgress)(timeoutTimestamp, cancellationEnabled);
     let dirty = false;
     let dirtyReasons = [];
     let uploadLoopPromise = null;

package/dist/provider-implementation.d.ts

@@ -1,5 +1,5 @@
 import type { BundlerInternals } from '@remotion/bundler';
-import type { ChromiumOptions, EmittedArtifact, LogLevel } from '@remotion/renderer';
+import type { ChromiumOptions, EmittedArtifact, LogLevel, X264Preset } from '@remotion/renderer';
 import type { CloudProvider, DeleteAfter, GetFolderFiles, Privacy, ProviderSpecifics, ReceivedArtifact, WebhookPayload } from '@remotion/serverless-client';
 import type { LaunchedBrowser } from './get-browser-instance';
 export type MakeArtifactWithDetails<Provider extends CloudProvider> = (params: {
@@ -79,6 +79,7 @@ export type InvokeWebhookParams = {
 };
 export type InvokeWebhook = (params: InvokeWebhookParams) => Promise<void>;
 export type InsideFunctionSpecifics<Provider extends CloudProvider> = {
+    defaultX264Preset: X264Preset | null;
     getBrowserInstance: GetBrowserInstance;
     forgetBrowserEventLoop: ForgetBrowserEventLoop;
     timer: DebuggingTimer;

package/dist/stream-renderer.js

@@ -12,6 +12,29 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
         throw new Error('Expected renderer type');
     }
     return new Promise((resolve) => {
+        const chunkFilename = (type) => (0, path_1.join)(outdir, `chunk:${String(payload.chunk).padStart(8, '0')}:${type}`);
+        // Stream the chunks to disk as they arrive instead of buffering them
+        // in memory. With many chunks arriving concurrently, buffering can
+        // exhaust the memory of the main function.
+        const getBinaryPayloadSink = ({ messageType }) => {
+            const filename = chunkFilename(messageType === 'video-chunk-rendered' ? 'video' : 'audio');
+            const writeStream = (0, fs_1.createWriteStream)(filename);
+            return {
+                write: (data) => new Promise((resolve_, reject) => {
+                    writeStream.write(data, (err) => {
+                        if (err) {
+                            reject(err);
+                        }
+                        else {
+                            resolve_();
+                        }
+                    });
+                }),
+                end: () => new Promise((resolve_) => {
+                    writeStream.end(resolve_);
+                }),
+            };
+        };
         const receivedStreamingPayload = ({ message }) => {
             if (message.type === 'lambda-invoked') {
                 overallProgress.setLambdaInvoked(payload.chunk);
@@ -26,15 +49,21 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
                 return;
             }
             if (message.type === 'video-chunk-rendered') {
-                const filename = (0, path_1.join)(outdir, `chunk:${String(payload.chunk).padStart(8, '0')}:video`);
-                (0, fs_1.writeFileSync)(filename, new Uint8Array(message.payload));
+                const filename = chunkFilename('video');
+                // An empty payload means the chunk was already streamed to disk
+                if (message.payload.length > 0) {
+                    (0, fs_1.writeFileSync)(filename, message.payload);
+                }
                 files.push(filename);
                 renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Received video chunk for chunk ${payload.chunk}`);
                 return;
             }
             if (message.type === 'audio-chunk-rendered') {
-                const filename = (0, path_1.join)(outdir, `chunk:${String(payload.chunk).padStart(8, '0')}:audio`);
-                (0, fs_1.writeFileSync)(filename, new Uint8Array(message.payload));
+                const filename = chunkFilename('audio');
+                // An empty payload means the chunk was already streamed to disk
+                if (message.payload.length > 0) {
+                    (0, fs_1.writeFileSync)(filename, message.payload);
+                }
                 renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Received audio chunk for chunk ${payload.chunk}`);
                 files.push(filename);
                 return;
@@ -91,6 +120,7 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
             type: serverless_client_1.ServerlessRoutines.renderer,
             receivedStreamingPayload,
             requestHandler,
+            getBinaryPayloadSink,
         })
             .then(() => {
             resolve({

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/serverless"
 	},
 	"name": "@remotion/serverless",
-	"version": "4.0.514",
+	"version": "4.0.515",
 	"description": "A runtime for distributed rendering",
 	"main": "dist",
 	"scripts": {
@@ -23,13 +23,13 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@remotion/renderer": "4.0.514",
-		"@remotion/bundler": "4.0.514",
-		"@remotion/licensing": "4.0.514",
-		"@remotion/serverless-client": "4.0.514"
+		"@remotion/renderer": "4.0.515",
+		"@remotion/bundler": "4.0.515",
+		"@remotion/licensing": "4.0.515",
+		"@remotion/serverless-client": "4.0.515"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.514",
+		"@remotion/eslint-config-internal": "4.0.515",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},