@remotion/serverless 4.0.509 → 4.0.510

package/dist/create-post-render-data.js

@@ -22,6 +22,7 @@ const createPostRenderData = ({ region, memorySizeInMb, renderMetadata, errorExp
         throw new Error('Cannot wrap up without an output file in the S3 bucket.');
     }
     const endTime = Date.now();
+    const billingCurrency = providerSpecifics.getBillingCurrency(region);
     if (overallProgress.timeToEncode === null) {
         throw new Error('Expected time to encode to be set');
     }
@@ -30,11 +31,11 @@ const createPostRenderData = ({ region, memorySizeInMb, renderMetadata, errorExp
     }
     return {
         cost: {
-            currency: 'USD',
+            currency: billingCurrency,
             disclaimer: 'Estimated cost for function invocations only. Does not include cost for storage and data transfer.',
             estimatedCost: cost,
-            estimatedDisplayCost: `$${new Intl.NumberFormat('en-US', {
-                currency: 'USD',
+            estimatedDisplayCost: `${billingCurrency === 'CNY' ? '¥' : '$'}${new Intl.NumberFormat('en-US', {
+                currency: billingCurrency,
                 currencyDisplay: 'narrowSymbol',
             }).format(cost)}`,
         },

package/dist/handlers/launch.js

@@ -351,7 +351,7 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
         return { alreadyExisted: false };
     };
     await Promise.all(lambdaPayloads.map(async (payload) => {
-        await (0, stream_renderer_1.streamRendererFunctionWithRetry)({
+        await (0, stream_renderer_1.renderRendererFunctionWithRetry)({
             files,
             functionName: rendererFunctionName,
             outdir,
@@ -362,6 +362,7 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
             providerSpecifics,
             insideFunctionSpecifics,
             requestHandler: null,
+            expectedBucketOwner: options.expectedBucketOwner,
         });
     }));
     const postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
@@ -401,6 +402,29 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
         requestHandler: null,
         sampleRate: params.sampleRate,
     });
+    if (providerSpecifics.getRendererFunctionTransport(insideFunctionSpecifics.getCurrentRegionInFunction()) === 's3') {
+        try {
+            const transportObjects = await providerSpecifics.listObjects({
+                bucketName: params.bucketName,
+                prefix: (0, serverless_client_2.rendererTransportPrefix)(params.renderId),
+                region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+                expectedBucketOwner: options.expectedBucketOwner,
+                forcePathStyle: params.forcePathStyle,
+                requestHandler: null,
+            });
+            await Promise.all(transportObjects.map((object) => providerSpecifics.deleteFile({
+                bucketName: params.bucketName,
+                key: object.Key,
+                region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+                customCredentials: null,
+                forcePathStyle: params.forcePathStyle,
+                requestHandler: null,
+            })));
+        }
+        catch (err) {
+            renderer_1.RenderInternals.Log.warn({ indent: false, logLevel: params.logLevel }, 'Could not clean up renderer transport objects', err);
+        }
+    }
     return postRenderData;
 };
 const launchHandler = async ({ params, options, providerSpecifics, insideFunctionSpecifics, }) => {

package/dist/handlers/renderer.d.ts

@@ -9,12 +9,18 @@ export type RequestContext = {
     getRemainingTimeInMillis: () => number;
     awsRequestId: string;
 };
-export declare const rendererHandler: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, }: {
+export declare const rendererHandler: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, onMediaFiles, }: {
     params: ServerlessPayload<Provider>;
     options: Options;
     onStream: OnStream<Provider>;
     requestContext: RequestContext;
     providerSpecifics: ProviderSpecifics<Provider>;
     insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
+    onMediaFiles: ((options: {
+        videoOutputLocation: string;
+        audioOutputLocation: string | null;
+        isAudioOnly: boolean;
+        completedAt: number;
+    }) => Promise<void>) | null;
 }) => Promise<void>;
 export {};

package/dist/handlers/renderer.js

@@ -13,7 +13,7 @@ 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, }) => {
+const renderHandler = async ({ params, options, logs, onStream, providerSpecifics, insideFunctionSpecifics, onBrowserInstance, onMediaFiles, }) => {
     if (params.type !== serverless_client_1.ServerlessRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -247,15 +247,24 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
             .catch((err) => reject(err));
     });
     const streamTimer = insideFunctionSpecifics.timer('Streaming chunk to the main function', params.logLevel);
-    if (audioOutputLocation) {
-        const audioChunkTimer = insideFunctionSpecifics.timer('Sending audio chunk', params.logLevel);
-        await onStream({
-            type: 'audio-chunk-rendered',
-            payload: new Uint8Array(node_fs_1.default.readFileSync(audioOutputLocation)),
+    const endRendered = Date.now();
+    if (onMediaFiles) {
+        await onMediaFiles({
+            videoOutputLocation,
+            audioOutputLocation,
+            isAudioOnly: pure_1.NoReactAPIs.isAudioCodec(params.codec),
+            completedAt: endRendered,
         });
-        audioChunkTimer.end();
     }
-    if (videoOutputLocation) {
+    else {
+        if (audioOutputLocation) {
+            const audioChunkTimer = insideFunctionSpecifics.timer('Sending audio chunk', params.logLevel);
+            await onStream({
+                type: 'audio-chunk-rendered',
+                payload: new Uint8Array(node_fs_1.default.readFileSync(audioOutputLocation)),
+            });
+            audioChunkTimer.end();
+        }
         const videoChunkTimer = insideFunctionSpecifics.timer('Sending main chunk', params.logLevel);
         await onStream({
             type: pure_1.NoReactAPIs.isAudioCodec(params.codec)
@@ -265,7 +274,6 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
         });
         videoChunkTimer.end();
     }
-    const endRendered = Date.now();
     await onStream({
         type: 'chunk-complete',
         payload: {
@@ -286,7 +294,7 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
     return {};
 };
 const ENABLE_SLOW_LEAK_DETECTION = false;
-const rendererHandler = async ({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, }) => {
+const rendererHandler = async ({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, onMediaFiles, }) => {
     if (params.type !== serverless_client_1.ServerlessRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -305,6 +313,7 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
             onBrowserInstance: (browserInstance) => {
                 instance = browserInstance;
             },
+            onMediaFiles,
         });
     }
     catch (err) {
@@ -323,7 +332,7 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
         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);
-        onStream({
+        await onStream({
             type: 'error-occurred',
             payload: {
                 error: err.stack,

package/dist/handlers/still.js

@@ -303,7 +303,7 @@ const innerStillHandler = async ({ params, expectedBucketOwner, renderId, onStre
         size,
         sizeInBytes: size,
         bucketName,
-        estimatedPrice: (0, serverless_client_1.formatCostsInfo)(estimatedPrice),
+        estimatedPrice: (0, serverless_client_1.formatCostsInfo)(estimatedPrice, providerSpecifics.getBillingCurrency(insideFunctionSpecifics.getCurrentRegionInFunction())),
         renderId,
         outKey,
         receivedArtifacts: receivedArtifact,

package/dist/inner-routine.js

@@ -13,6 +13,7 @@ const info_1 = require("./info");
 const is_warm_1 = require("./is-warm");
 const leak_detection_1 = require("./leak-detection");
 const print_logging_grep_helper_1 = require("./print-logging-grep-helper");
+const s3_renderer_output_1 = require("./s3-renderer-output");
 const innerHandler = async ({ params, responseWriter, context, providerSpecifics, insideFunctionSpecifics, }) => {
     (0, leak_detection_1.setCurrentRequestId)(context.awsRequestId);
     process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
@@ -81,6 +82,14 @@ const innerHandler = async ({ params, responseWriter, context, providerSpecifics
                     timeoutInMilliseconds,
                     providerSpecifics,
                     insideFunctionSpecifics,
+                })
+                    .then((r) => {
+                    if (!params.streamed && r.type === 'error') {
+                        return responseWriter
+                            .write(new TextEncoder().encode(JSON.stringify(r)))
+                            .then(() => r);
+                    }
+                    return r;
                 })
                     .then((r) => {
                     resolve(r);
@@ -183,29 +192,44 @@ const innerHandler = async ({ params, responseWriter, context, providerSpecifics
                 isWarm,
             }, params.logLevel);
         }
+        const region = insideFunctionSpecifics.getCurrentRegionInFunction();
+        const transport = providerSpecifics.getRendererFunctionTransport(region);
+        const s3Output = transport === 's3'
+            ? (0, s3_renderer_output_1.makeS3RendererOutput)({
+                params,
+                expectedBucketOwner: currentUserId,
+                region,
+                providerSpecifics,
+            })
+            : null;
+        await (s3Output === null || s3Output === void 0 ? void 0 : s3Output.initialize());
         await new Promise((resolve, reject) => {
+            var _a;
             (0, renderer_2.rendererHandler)({
                 params,
                 options: {
                     expectedBucketOwner: currentUserId,
                     isWarm,
                 },
-                onStream: (payload) => {
-                    const message = (0, serverless_client_1.makeStreamPayload)({
-                        message: payload,
-                    });
-                    const writeProm = responseWriter.write(message);
-                    return new Promise((innerResolve, innerReject) => {
-                        writeProm
-                            .then(() => {
-                            innerResolve();
-                        })
-                            .catch((err) => {
-                            reject(err);
-                            innerReject(err);
+                onStream: s3Output
+                    ? s3Output.onStream
+                    : (payload) => {
+                        const message = (0, serverless_client_1.makeStreamPayload)({
+                            message: payload,
                         });
-                    });
-                },
+                        const writeProm = responseWriter.write(message);
+                        return new Promise((innerResolve, innerReject) => {
+                            writeProm
+                                .then(() => {
+                                innerResolve();
+                            })
+                                .catch((err) => {
+                                reject(err);
+                                innerReject(err);
+                            });
+                        });
+                    },
+                onMediaFiles: (_a = s3Output === null || s3Output === void 0 ? void 0 : s3Output.uploadMediaAndComplete) !== null && _a !== void 0 ? _a : null,
                 requestContext: context,
                 providerSpecifics,
                 insideFunctionSpecifics,

package/dist/s3-renderer-output.d.ts

@@ -0,0 +1,21 @@
+import type { EmittedArtifact } from '@remotion/renderer';
+import type { CloudProvider, OnStream, ProviderSpecifics, S3RendererArtifactMetadata, ServerlessPayload } from '@remotion/serverless-client';
+export declare const makeS3RendererOutput: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ params, expectedBucketOwner, region, providerSpecifics, }: {
+    params: ServerlessPayload<Provider>;
+    expectedBucketOwner: string;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => {
+    initialize: () => Promise<void>;
+    onStream: OnStream<Provider>;
+    uploadMediaAndComplete: ({ videoOutputLocation, audioOutputLocation, isAudioOnly, completedAt, }: {
+        videoOutputLocation: string;
+        audioOutputLocation: string | null;
+        isAudioOnly: boolean;
+        completedAt: number;
+    }) => Promise<void>;
+};
+export declare const artifactFromS3: ({ metadata, content, }: {
+    metadata: S3RendererArtifactMetadata;
+    content: Uint8Array<ArrayBufferLike>;
+}) => EmittedArtifact;

package/dist/s3-renderer-output.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.artifactFromS3 = exports.makeS3RendererOutput = void 0;
+const node_fs_1 = require("node:fs");
+const serverless_client_1 = require("@remotion/serverless-client");
+const makeS3RendererOutput = ({ params, expectedBucketOwner, region, providerSpecifics, }) => {
+    if (params.type !== serverless_client_1.ServerlessRoutines.renderer) {
+        throw new Error('Expected renderer payload');
+    }
+    const startedAt = Date.now();
+    let lambdaInvoked = true;
+    let renderedFrames = 0;
+    let encodedFrames = 0;
+    let writeQueue = Promise.resolve();
+    const artifacts = [];
+    const artifactUploads = [];
+    const statusKey = (0, serverless_client_1.rendererTransportStatusKey)({
+        renderId: params.renderId,
+        chunk: params.chunk,
+        attempt: params.attempt,
+    });
+    const writeStatus = (status) => {
+        writeQueue = writeQueue.then(() => providerSpecifics.writeFile({
+            bucketName: params.bucketName,
+            key: statusKey,
+            body: JSON.stringify(status),
+            region,
+            privacy: 'private',
+            expectedBucketOwner,
+            downloadBehavior: null,
+            customCredentials: null,
+            forcePathStyle: params.forcePathStyle,
+            storageClass: null,
+            requestHandler: null,
+        }));
+        return writeQueue;
+    };
+    const runningStatus = () => ({
+        schema: 1,
+        state: 'running',
+        chunk: params.chunk,
+        attempt: params.attempt,
+        lambdaInvoked,
+        renderedFrames,
+        encodedFrames,
+        startedAt,
+    });
+    const initialize = () => writeStatus(runningStatus());
+    const onStream = async (message) => {
+        if (message.type === 'lambda-invoked') {
+            lambdaInvoked = true;
+            await writeStatus(runningStatus());
+            return;
+        }
+        if (message.type === 'frames-rendered') {
+            renderedFrames = Math.max(renderedFrames, message.payload.rendered);
+            encodedFrames = Math.max(encodedFrames, message.payload.encoded);
+            await writeStatus(runningStatus());
+            return;
+        }
+        if (message.type === 'artifact-emitted') {
+            const artifact = (0, serverless_client_1.deserializeArtifact)(message.payload.artifact);
+            const key = (0, serverless_client_1.rendererTransportArtifactKey)({
+                renderId: params.renderId,
+                chunk: params.chunk,
+                attempt: params.attempt,
+            }, artifacts.length);
+            const metadata = {
+                filename: artifact.filename,
+                frame: artifact.frame,
+                binary: artifact.content instanceof Uint8Array,
+                downloadBehavior: artifact.downloadBehavior,
+            };
+            artifacts.push({ key, metadata });
+            const upload = providerSpecifics.writeFile({
+                bucketName: params.bucketName,
+                key,
+                body: artifact.content,
+                region,
+                privacy: 'private',
+                expectedBucketOwner,
+                downloadBehavior: null,
+                customCredentials: null,
+                forcePathStyle: params.forcePathStyle,
+                storageClass: null,
+                requestHandler: null,
+            });
+            artifactUploads.push(upload);
+            await upload;
+            return;
+        }
+        if (message.type === 'error-occurred') {
+            await writeStatus({
+                schema: 1,
+                state: 'failed',
+                chunk: params.chunk,
+                attempt: params.attempt,
+                lambdaInvoked,
+                renderedFrames,
+                encodedFrames,
+                startedAt,
+                failedAt: Date.now(),
+                errorInfo: message.payload.errorInfo,
+                shouldRetry: message.payload.shouldRetry,
+            });
+            return;
+        }
+        if (message.type === 'chunk-complete') {
+            return;
+        }
+        throw new Error(`Unexpected ${message.type} event in S3 renderer transport`);
+    };
+    const uploadMediaAndComplete = async ({ videoOutputLocation, audioOutputLocation, isAudioOnly, completedAt, }) => {
+        const videoKey = isAudioOnly
+            ? null
+            : (0, serverless_client_1.rendererTransportVideoKey)({
+                renderId: params.renderId,
+                chunk: params.chunk,
+                attempt: params.attempt,
+            });
+        const audioKey = audioOutputLocation || isAudioOnly
+            ? (0, serverless_client_1.rendererTransportAudioKey)({
+                renderId: params.renderId,
+                chunk: params.chunk,
+                attempt: params.attempt,
+            })
+            : null;
+        await Promise.all([
+            ...artifactUploads,
+            videoKey
+                ? providerSpecifics.writeFile({
+                    bucketName: params.bucketName,
+                    key: videoKey,
+                    body: (0, node_fs_1.createReadStream)(videoOutputLocation),
+                    region,
+                    privacy: 'private',
+                    expectedBucketOwner,
+                    downloadBehavior: null,
+                    customCredentials: null,
+                    forcePathStyle: params.forcePathStyle,
+                    storageClass: null,
+                    requestHandler: null,
+                })
+                : null,
+            audioKey
+                ? providerSpecifics.writeFile({
+                    bucketName: params.bucketName,
+                    key: audioKey,
+                    body: (0, node_fs_1.createReadStream)(audioOutputLocation !== null && audioOutputLocation !== void 0 ? audioOutputLocation : videoOutputLocation),
+                    region,
+                    privacy: 'private',
+                    expectedBucketOwner,
+                    downloadBehavior: null,
+                    customCredentials: null,
+                    forcePathStyle: params.forcePathStyle,
+                    storageClass: null,
+                    requestHandler: null,
+                })
+                : null,
+        ]);
+        lambdaInvoked = true;
+        await writeStatus({
+            schema: 1,
+            state: 'completed',
+            chunk: params.chunk,
+            attempt: params.attempt,
+            lambdaInvoked: true,
+            renderedFrames,
+            encodedFrames,
+            startedAt,
+            completedAt,
+            videoKey,
+            audioKey,
+            artifacts,
+        });
+    };
+    return { initialize, onStream, uploadMediaAndComplete };
+};
+exports.makeS3RendererOutput = makeS3RendererOutput;
+const artifactFromS3 = ({ metadata, content, }) => ({
+    filename: metadata.filename,
+    frame: metadata.frame,
+    downloadBehavior: metadata.downloadBehavior,
+    content: metadata.binary ? content : new TextDecoder().decode(content),
+});
+exports.artifactFromS3 = artifactFromS3;

package/dist/stream-renderer.d.ts

@@ -2,7 +2,7 @@ import type { EmittedArtifact } from '@remotion/renderer';
 import type { CloudProvider, ProviderSpecifics, ServerlessPayload } from '@remotion/serverless-client';
 import type { OverallProgressHelper } from './overall-render-progress';
 import type { InsideFunctionSpecifics } from './provider-implementation';
-export declare const streamRendererFunctionWithRetry: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, insideFunctionSpecifics, requestHandler, }: {
+export declare const renderRendererFunctionWithRetry: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, insideFunctionSpecifics, requestHandler, expectedBucketOwner, }: {
     payload: ServerlessPayload<Provider>;
     functionName: string;
     outdir: string;
@@ -15,4 +15,5 @@ export declare const streamRendererFunctionWithRetry: <Provider extends CloudPro
     providerSpecifics: ProviderSpecifics<Provider>;
     insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
     requestHandler: Provider["requestHandler"] | null;
+    expectedBucketOwner: string;
 }) => Promise<unknown>;

package/dist/stream-renderer.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamRendererFunctionWithRetry = void 0;
+exports.renderRendererFunctionWithRetry = void 0;
 const fs_1 = require("fs");
+const promises_1 = require("node:stream/promises");
 const path_1 = require("path");
 const renderer_1 = require("@remotion/renderer");
 const serverless_client_1 = require("@remotion/serverless-client");
+const s3_renderer_output_1 = require("./s3-renderer-output");
 const streamRenderer = ({ payload, functionName, outdir, overallProgress, files, logLevel, onArtifact, providerSpecifics, insideFunctionSpecifics, requestHandler, }) => {
     if (payload.type !== serverless_client_1.ServerlessRoutines.renderer) {
         throw new Error('Expected renderer type');
@@ -110,11 +112,232 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
         });
     });
 };
-const streamRendererFunctionWithRetry = async ({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, insideFunctionSpecifics, requestHandler, }) => {
+const wait = (duration) => new Promise((resolve) => setTimeout(resolve, duration));
+const isMissingObjectError = (err) => {
+    const error = err;
+    return (error.name === 'NoSuchKey' ||
+        error.name === 'NotFound' ||
+        error.Code === 'NoSuchKey' ||
+        error.code === 'NoSuchKey');
+};
+const readStreamAsBytes = async (stream) => {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(typeof chunk === 'string'
+            ? new TextEncoder().encode(chunk)
+            : new Uint8Array(chunk));
+    }
+    const size = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+};
+const s3Renderer = async ({ payload, functionName, outdir, overallProgress, files, logLevel, onArtifact, providerSpecifics, insideFunctionSpecifics, requestHandler, expectedBucketOwner, }) => {
+    var _a, _b;
+    if (payload.type !== serverless_client_1.ServerlessRoutines.renderer) {
+        throw new Error('Expected renderer type');
+    }
+    const region = insideFunctionSpecifics.getCurrentRegionInFunction();
+    try {
+        await providerSpecifics.callFunctionAsync({
+            functionName,
+            payload,
+            region,
+            timeoutInTest: 12000,
+            type: serverless_client_1.ServerlessRoutines.renderer,
+            requestHandler,
+        });
+    }
+    catch (err) {
+        return {
+            type: 'error',
+            error: (_a = err.stack) !== null && _a !== void 0 ? _a : err.message,
+            shouldRetry: providerSpecifics.isFlakyError(err),
+        };
+    }
+    const statusKey = (0, serverless_client_1.rendererTransportStatusKey)({
+        renderId: payload.renderId,
+        chunk: payload.chunk,
+        attempt: payload.attempt,
+    });
+    let lastRendered = 0;
+    let lastEncoded = 0;
+    let lambdaInvoked = false;
+    let pollingInterval = 250;
+    const timeoutTimestamp = overallProgress.get().timeoutTimestamp - 1000;
+    while (Date.now() < timeoutTimestamp) {
+        try {
+            const statusStream = await providerSpecifics.readFile({
+                bucketName: payload.bucketName,
+                key: statusKey,
+                region,
+                expectedBucketOwner,
+                forcePathStyle: payload.forcePathStyle,
+                requestHandler,
+            });
+            const status = (0, serverless_client_1.parseS3RendererStatus)({
+                value: JSON.parse(await (0, serverless_client_1.streamToString)(statusStream)),
+                expectedChunk: payload.chunk,
+                expectedAttempt: payload.attempt,
+            });
+            if (status.lambdaInvoked && !lambdaInvoked) {
+                lambdaInvoked = true;
+                overallProgress.setLambdaInvoked(payload.chunk);
+            }
+            if (status.renderedFrames > lastRendered ||
+                status.encodedFrames > lastEncoded) {
+                lastRendered = Math.max(lastRendered, status.renderedFrames);
+                lastEncoded = Math.max(lastEncoded, status.encodedFrames);
+                overallProgress.setFrames({
+                    index: payload.chunk,
+                    rendered: lastRendered,
+                    encoded: lastEncoded,
+                });
+            }
+            if (status.state === 'failed') {
+                overallProgress.addErrorWithoutUpload(status.errorInfo);
+                overallProgress.setFrames({
+                    encoded: 0,
+                    index: payload.chunk,
+                    rendered: 0,
+                });
+                await providerSpecifics
+                    .deleteFile({
+                    bucketName: payload.bucketName,
+                    key: statusKey,
+                    region,
+                    customCredentials: null,
+                    forcePathStyle: payload.forcePathStyle,
+                    requestHandler,
+                })
+                    .catch(() => undefined);
+                return {
+                    type: 'error',
+                    error: status.errorInfo.stack,
+                    shouldRetry: status.shouldRetry,
+                };
+            }
+            if (status.state === 'completed') {
+                const downloadedKeys = [];
+                const emittedArtifacts = [];
+                for (const artifact of status.artifacts) {
+                    let artifactStream;
+                    try {
+                        artifactStream = await providerSpecifics.readFile({
+                            bucketName: payload.bucketName,
+                            key: artifact.key,
+                            region,
+                            expectedBucketOwner,
+                            forcePathStyle: payload.forcePathStyle,
+                            requestHandler,
+                        });
+                    }
+                    catch (err) {
+                        if (isMissingObjectError(err)) {
+                            throw new Error(`Renderer completed manifest references missing artifact object ${artifact.key}`);
+                        }
+                        throw err;
+                    }
+                    emittedArtifacts.push((0, s3_renderer_output_1.artifactFromS3)({
+                        metadata: artifact.metadata,
+                        content: await readStreamAsBytes(artifactStream),
+                    }));
+                    downloadedKeys.push(artifact.key);
+                }
+                const downloadedFiles = [];
+                for (const [type, key] of [
+                    ['video', status.videoKey],
+                    ['audio', status.audioKey],
+                ]) {
+                    if (!key) {
+                        continue;
+                    }
+                    const filename = (0, path_1.join)(outdir, `chunk-${String(payload.chunk).padStart(8, '0')}-${type}`);
+                    let media;
+                    try {
+                        media = await providerSpecifics.readFile({
+                            bucketName: payload.bucketName,
+                            key,
+                            region,
+                            expectedBucketOwner,
+                            forcePathStyle: payload.forcePathStyle,
+                            requestHandler,
+                        });
+                    }
+                    catch (err) {
+                        if (isMissingObjectError(err)) {
+                            throw new Error(`Renderer completed manifest references missing media object ${key}`);
+                        }
+                        throw err;
+                    }
+                    await (0, promises_1.pipeline)(media, (0, fs_1.createWriteStream)(filename));
+                    downloadedFiles.push(filename);
+                    downloadedKeys.push(key);
+                }
+                for (const emittedArtifact of emittedArtifacts) {
+                    const { alreadyExisted } = onArtifact(emittedArtifact);
+                    if (alreadyExisted) {
+                        return {
+                            type: 'error',
+                            error: `Chunk ${payload.chunk} emitted an asset filename ${emittedArtifact.filename} at frame ${emittedArtifact.frame} but there is already another artifact with the same name. https://remotion.dev/docs/artifacts`,
+                            shouldRetry: false,
+                        };
+                    }
+                }
+                files.push(...downloadedFiles);
+                overallProgress.addChunkCompleted(payload.chunk, status.startedAt, status.completedAt);
+                for (const key of [...downloadedKeys, statusKey]) {
+                    await providerSpecifics
+                        .deleteFile({
+                        bucketName: payload.bucketName,
+                        key,
+                        region,
+                        customCredentials: null,
+                        forcePathStyle: payload.forcePathStyle,
+                        requestHandler,
+                    })
+                        .catch((err) => {
+                        renderer_1.RenderInternals.Log.warn({ indent: false, logLevel }, `Could not clean up renderer transport object ${key}`, err);
+                    });
+                }
+                return { type: 'success' };
+            }
+        }
+        catch (err) {
+            if (!isMissingObjectError(err) &&
+                !providerSpecifics.isFlakyError(err)) {
+                return {
+                    type: 'error',
+                    error: (_b = err.stack) !== null && _b !== void 0 ? _b : err.message,
+                    shouldRetry: false,
+                };
+            }
+        }
+        await wait(pollingInterval);
+        pollingInterval = Math.min(2000, Math.round(pollingInterval * 1.5));
+    }
+    return {
+        type: 'error',
+        error: `Renderer chunk ${payload.chunk}, attempt ${payload.attempt} did not publish a status before the launcher deadline. Logs: ${providerSpecifics.getLoggingUrlForRendererFunction({
+            region,
+            functionName,
+            rendererFunctionName: functionName,
+            renderId: payload.renderId,
+            chunk: payload.chunk,
+        })}`,
+        shouldRetry: false,
+    };
+};
+const renderRendererFunctionWithRetry = async ({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, insideFunctionSpecifics, requestHandler, expectedBucketOwner, }) => {
     if (payload.type !== serverless_client_1.ServerlessRoutines.renderer) {
         throw new Error('Expected renderer type');
     }
-    const result = await streamRenderer({
+    const transport = providerSpecifics.getRendererFunctionTransport(insideFunctionSpecifics.getCurrentRegionInFunction());
+    const result = await (transport === 's3' ? s3Renderer : streamRenderer)({
         files,
         functionName,
         outdir,
@@ -125,9 +348,10 @@ const streamRendererFunctionWithRetry = async ({ payload, files, functionName, o
         providerSpecifics,
         insideFunctionSpecifics,
         requestHandler,
+        expectedBucketOwner,
     });
     if (result.type === 'error') {
-        if (!result.shouldRetry) {
+        if (!result.shouldRetry || payload.retriesLeft <= 0) {
             throw new Error(result.error);
         }
         overallProgress.addRetry({
@@ -135,7 +359,7 @@ const streamRendererFunctionWithRetry = async ({ payload, files, functionName, o
             time: Date.now(),
             chunk: payload.chunk,
         });
-        return (0, exports.streamRendererFunctionWithRetry)({
+        return (0, exports.renderRendererFunctionWithRetry)({
             files,
             functionName,
             outdir,
@@ -150,7 +374,8 @@ const streamRendererFunctionWithRetry = async ({ payload, files, functionName, o
             providerSpecifics,
             insideFunctionSpecifics,
             requestHandler,
+            expectedBucketOwner,
         });
     }
 };
-exports.streamRendererFunctionWithRetry = streamRendererFunctionWithRetry;
+exports.renderRendererFunctionWithRetry = renderRendererFunctionWithRetry;

package/package.json

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