@remotion/lambda 4.0.16 → 4.0.18

package/dist/api/get-compositions-on-lambda.js

@@ -47,6 +47,7 @@ const getCompositionsOnLambda = async ({ chromiumOptions, serveUrl, region, inpu
             region,
             receivedStreamingPayload: () => undefined,
             timeoutInTest: 120000,
+            retriesRemaining: 0,
         });
         return res.compositions;
     }

package/dist/api/get-render-progress.js

@@ -22,6 +22,7 @@ const getRenderProgress = async (input) => {
         region: input.region,
         receivedStreamingPayload: () => undefined,
         timeoutInTest: 120000,
+        retriesRemaining: 2,
     });
     return result;
 };

package/dist/api/render-media-on-lambda.js

@@ -35,6 +35,7 @@ const renderMediaOnLambda = async (input) => {
             region,
             receivedStreamingPayload: () => undefined,
             timeoutInTest: 120000,
+            retriesRemaining: 0,
         });
         return {
             renderId: res.renderId,

package/dist/api/render-still-on-lambda.js

@@ -77,6 +77,7 @@ const renderStillOnLambda = async ({ functionName, serveUrl, inputProps, imageFo
                 }
             },
             timeoutInTest: 120000,
+            retriesRemaining: 0,
         });
         return {
             estimatedPrice: res.estimatedPrice,

package/dist/cli/log.d.ts

@@ -2,24 +2,24 @@ export declare const Log: {
     verbose: (message?: any, ...optionalParams: any[]) => void;
     verboseAdvanced: (options: {
         indent: boolean;
-        logLevel: "info" | "error" | "verbose" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     } & {
         tag?: string | undefined;
     }, message?: any, ...optionalParams: any[]) => void;
     info: (message?: any, ...optionalParams: any[]) => void;
     infoAdvanced: (options: {
         indent: boolean;
-        logLevel: "info" | "error" | "verbose" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     }, message?: any, ...optionalParams: any[]) => void;
     warn: (message?: any, ...optionalParams: any[]) => void;
     warnAdvanced: (options: {
         indent: boolean;
-        logLevel: "info" | "error" | "verbose" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     }, message?: any, ...optionalParams: any[]) => void;
     error: (message?: any, ...optionalParams: any[]) => void;
     errorAdvanced: (options: {
         indent: boolean;
-        logLevel: "info" | "error" | "verbose" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     } & {
         tag?: string | undefined;
     }, message?: any, ...optionalParams: any[]) => void;

package/dist/functions/helpers/concat-videos.d.ts

@@ -9,7 +9,7 @@ export declare const getAllFilesS3: ({ bucket, expectedFiles, outdir, renderId,
     renderId: string;
     region: AwsRegion;
     expectedBucketOwner: string;
-    onErrors: (errors: EnhancedErrorInfo[]) => Promise<void>;
+    onErrors: (errors: EnhancedErrorInfo[]) => void;
 }) => Promise<string[]>;
 export declare const concatVideosS3: ({ onProgress, numberOfFrames, codec, fps, numberOfGifLoops, files, outdir, audioCodec, }: {
     onProgress: (frames: number) => void;

package/dist/functions/helpers/concat-videos.js

@@ -96,7 +96,7 @@ const getAllFilesS3 = ({ bucket, expectedFiles, outdir, renderId, region, expect
                 renderId,
             })).filter((e) => e.isFatal);
             if (errors.length > 0) {
-                await onErrors(errors);
+                onErrors(errors);
                 // Will die here
             }
             filesInBucket.forEach(async (key) => {

package/dist/functions/launch.js

@@ -89,51 +89,7 @@ const innerLaunchHandler = async (params, options) => {
     }
     const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : process.env.AWS_LAMBDA_FUNCTION_NAME;
     const startedDate = Date.now();
-    let webhookInvoked = false;
-    console.log(`Function has ${Math.max(options.getRemainingTimeInMillis() - 1000, 1000)} before it times out`);
     const verbose = renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose');
-    const webhookDueToTimeout = setTimeout(async () => {
-        if (params.webhook && !webhookInvoked) {
-            try {
-                await (0, invoke_webhook_1.invokeWebhook)({
-                    url: params.webhook.url,
-                    secret: params.webhook.secret,
-                    payload: {
-                        type: 'timeout',
-                        renderId: params.renderId,
-                        expectedBucketOwner: options.expectedBucketOwner,
-                        bucketName: params.bucketName,
-                    },
-                });
-                webhookInvoked = true;
-            }
-            catch (err) {
-                if (process.env.NODE_ENV === 'test') {
-                    throw err;
-                }
-                await (0, write_lambda_error_1.writeLambdaError)({
-                    bucketName: params.bucketName,
-                    errorInfo: {
-                        type: 'webhook',
-                        message: err.message,
-                        name: err.name,
-                        stack: err.stack,
-                        tmpDir: null,
-                        frame: 0,
-                        chunk: 0,
-                        isFatal: false,
-                        attempt: 1,
-                        willRetry: false,
-                        totalAttempts: 1,
-                    },
-                    renderId: params.renderId,
-                    expectedBucketOwner: options.expectedBucketOwner,
-                });
-                console.log('Failed to invoke webhook:');
-                console.log(err);
-            }
-        }
-    }, Math.max(options.getRemainingTimeInMillis() - 1000, 1000));
     const browserInstance = await (0, get_browser_instance_1.getBrowserInstance)(params.logLevel, false, params.chromiumOptions);
     const inputPropsPromise = (0, compress_props_1.decompressInputProps)({
         bucketName: params.bucketName,
@@ -245,7 +201,7 @@ const innerLaunchHandler = async (params, options) => {
         };
         return payload;
     });
-    console.log('Render plan: ', chunks.map((c, i) => `Chunk ${i} (Frames ${c[0]} - ${c[1]})`).join(', '));
+    renderer_1.RenderInternals.Log.info('Render plan: ', chunks.map((c, i) => `Chunk ${i} (Frames ${c[0]} - ${c[1]})`).join(', '));
     const renderMetadata = {
         startedDate,
         videoConfig: comp,
@@ -349,30 +305,8 @@ const innerLaunchHandler = async (params, options) => {
             });
         });
     };
-    const onErrors = async (errors) => {
-        var _a;
-        console.log('Found Errors', errors);
-        if (params.webhook) {
-            console.log('Sending webhook with errors');
-            await (0, invoke_webhook_1.invokeWebhook)({
-                url: params.webhook.url,
-                secret: (_a = params.webhook.secret) !== null && _a !== void 0 ? _a : null,
-                payload: {
-                    type: 'error',
-                    renderId: params.renderId,
-                    expectedBucketOwner: options.expectedBucketOwner,
-                    bucketName: params.bucketName,
-                    errors: errors.slice(0, 5).map((e) => ({
-                        message: e.message,
-                        name: e.name,
-                        stack: e.stack,
-                    })),
-                },
-            });
-        }
-        else {
-            console.log('No webhook specified');
-        }
+    const onErrors = (errors) => {
+        renderer_1.RenderInternals.Log.error('Found Errors', errors);
         const firstError = errors[0];
         if (firstError.chunk !== null) {
             throw new Error(`Stopping Lambda function because error occurred while rendering chunk ${firstError.chunk}:\n${errors[0].stack
@@ -462,6 +396,11 @@ const innerLaunchHandler = async (params, options) => {
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         serialized: params.inputProps,
     });
+    const cleanupResolvedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedResolvedProps)({
+        bucketName: params.bucketName,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        serialized: serializedResolvedProps,
+    });
     const outputUrl = (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(renderMetadata, params.bucketName, customCredentials);
     const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
         expectedBucketOwner: options.expectedBucketOwner,
@@ -472,7 +411,11 @@ const innerLaunchHandler = async (params, options) => {
         contents,
         errorExplanations: await errorExplanationsProm,
         timeToEncode: encodingStop - encodingStart,
-        timeToDelete: (await Promise.all([deletProm, cleanupSerializedInputPropsProm])).reduce((a, b) => a + b, 0),
+        timeToDelete: (await Promise.all([
+            deletProm,
+            cleanupSerializedInputPropsProm,
+            cleanupResolvedInputPropsProm,
+        ])).reduce((a, b) => a + b, 0),
         outputFile: {
             lastModified: Date.now(),
             size: outputSize.size,
@@ -494,60 +437,104 @@ const innerLaunchHandler = async (params, options) => {
         customCredentials: null,
     });
     await Promise.all([cleanupChunksProm, node_fs_1.default.promises.rm(outfile)]);
-    clearTimeout(webhookDueToTimeout);
-    if (params.webhook && !webhookInvoked) {
-        try {
-            await (0, invoke_webhook_1.invokeWebhook)({
-                url: params.webhook.url,
-                secret: params.webhook.secret,
-                payload: {
-                    type: 'success',
-                    renderId: params.renderId,
-                    expectedBucketOwner: options.expectedBucketOwner,
-                    bucketName: params.bucketName,
-                    outputUrl,
-                    lambdaErrors: postRenderData.errors,
-                    outputFile: postRenderData.outputFile,
-                    timeToFinish: postRenderData.timeToFinish,
-                    costs: postRenderData.cost,
-                },
-            });
-            webhookInvoked = true;
-        }
-        catch (err) {
-            if (process.env.NODE_ENV === 'test') {
-                throw err;
-            }
-            await (0, write_lambda_error_1.writeLambdaError)({
-                bucketName: params.bucketName,
-                errorInfo: {
-                    type: 'webhook',
-                    message: err.message,
-                    name: err.name,
-                    stack: err.stack,
-                    tmpDir: null,
-                    frame: 0,
-                    chunk: 0,
-                    isFatal: false,
-                    attempt: 1,
-                    willRetry: false,
-                    totalAttempts: 1,
-                },
-                renderId: params.renderId,
-                expectedBucketOwner: options.expectedBucketOwner,
-            });
-            console.log('Failed to invoke webhook:');
-            console.log(err);
-        }
-    }
+    return postRenderData;
 };
 const launchHandler = async (params, options) => {
-    var _a, _b;
     if (params.type !== constants_1.LambdaRoutines.launch) {
         throw new Error('Expected launch type');
     }
+    let webhookInvoked = false;
+    const webhookDueToTimeout = setTimeout(async () => {
+        if (params.webhook && !webhookInvoked) {
+            try {
+                await (0, invoke_webhook_1.invokeWebhook)({
+                    url: params.webhook.url,
+                    secret: params.webhook.secret,
+                    payload: {
+                        type: 'timeout',
+                        renderId: params.renderId,
+                        expectedBucketOwner: options.expectedBucketOwner,
+                        bucketName: params.bucketName,
+                    },
+                });
+                webhookInvoked = true;
+            }
+            catch (err) {
+                if (process.env.NODE_ENV === 'test') {
+                    throw err;
+                }
+                await (0, write_lambda_error_1.writeLambdaError)({
+                    bucketName: params.bucketName,
+                    errorInfo: {
+                        type: 'webhook',
+                        message: err.message,
+                        name: err.name,
+                        stack: err.stack,
+                        tmpDir: null,
+                        frame: 0,
+                        chunk: 0,
+                        isFatal: false,
+                        attempt: 1,
+                        willRetry: false,
+                        totalAttempts: 1,
+                    },
+                    renderId: params.renderId,
+                    expectedBucketOwner: options.expectedBucketOwner,
+                });
+                renderer_1.RenderInternals.Log.error('Failed to invoke webhook:');
+                renderer_1.RenderInternals.Log.error(err);
+            }
+        }
+    }, Math.max(options.getRemainingTimeInMillis() - 1000, 1000));
+    renderer_1.RenderInternals.Log.info(`Function has ${Math.max(options.getRemainingTimeInMillis() - 1000, 1000)} before it times out`);
     try {
-        await innerLaunchHandler(params, options);
+        const postRenderData = await innerLaunchHandler(params, options);
+        clearTimeout(webhookDueToTimeout);
+        if (params.webhook && !webhookInvoked) {
+            try {
+                await (0, invoke_webhook_1.invokeWebhook)({
+                    url: params.webhook.url,
+                    secret: params.webhook.secret,
+                    payload: {
+                        type: 'success',
+                        renderId: params.renderId,
+                        expectedBucketOwner: options.expectedBucketOwner,
+                        bucketName: params.bucketName,
+                        outputUrl: postRenderData.outputFile,
+                        lambdaErrors: postRenderData.errors,
+                        outputFile: postRenderData.outputFile,
+                        timeToFinish: postRenderData.timeToFinish,
+                        costs: postRenderData.cost,
+                    },
+                });
+                webhookInvoked = true;
+            }
+            catch (err) {
+                if (process.env.NODE_ENV === 'test') {
+                    throw err;
+                }
+                await (0, write_lambda_error_1.writeLambdaError)({
+                    bucketName: params.bucketName,
+                    errorInfo: {
+                        type: 'webhook',
+                        message: err.message,
+                        name: err.name,
+                        stack: err.stack,
+                        tmpDir: null,
+                        frame: 0,
+                        chunk: 0,
+                        isFatal: false,
+                        attempt: 1,
+                        willRetry: false,
+                        totalAttempts: 1,
+                    },
+                    renderId: params.renderId,
+                    expectedBucketOwner: options.expectedBucketOwner,
+                });
+                renderer_1.RenderInternals.Log.error('Failed to invoke webhook:');
+                renderer_1.RenderInternals.Log.error(err);
+            }
+        }
         return {
             type: 'success',
         };
@@ -556,7 +543,7 @@ const launchHandler = async (params, options) => {
         if (process.env.NODE_ENV === 'test') {
             throw err;
         }
-        console.log('Error occurred', err);
+        renderer_1.RenderInternals.Log.error('Error occurred', err);
         await (0, write_lambda_error_1.writeLambdaError)({
             bucketName: params.bucketName,
             errorInfo: {
@@ -575,11 +562,12 @@ const launchHandler = async (params, options) => {
             expectedBucketOwner: options.expectedBucketOwner,
             renderId: params.renderId,
         });
-        if ((_a = params.webhook) === null || _a === void 0 ? void 0 : _a.url) {
+        clearTimeout(webhookDueToTimeout);
+        if (params.webhook && !webhookInvoked) {
             try {
                 await (0, invoke_webhook_1.invokeWebhook)({
                     url: params.webhook.url,
-                    secret: (_b = params.webhook.secret) !== null && _b !== void 0 ? _b : null,
+                    secret: params.webhook.secret,
                     payload: {
                         type: 'error',
                         renderId: params.renderId,
@@ -592,6 +580,7 @@ const launchHandler = async (params, options) => {
                         })),
                     },
                 });
+                webhookInvoked = true;
             }
             catch (error) {
                 if (process.env.NODE_ENV === 'test') {
@@ -615,8 +604,8 @@ const launchHandler = async (params, options) => {
                     renderId: params.renderId,
                     expectedBucketOwner: options.expectedBucketOwner,
                 });
-                console.log('Failed to invoke webhook:');
-                console.log(error);
+                renderer_1.RenderInternals.Log.error('Failed to invoke webhook:');
+                renderer_1.RenderInternals.Log.error(error);
             }
         }
         throw err;

package/dist/functions/renderer.js

@@ -12,6 +12,7 @@ const call_lambda_1 = require("../shared/call-lambda");
 const chunk_progress_1 = require("../shared/chunk-progress");
 const compress_props_1 = require("../shared/compress-props");
 const constants_1 = require("../shared/constants");
+const is_flaky_error_1 = require("../shared/is-flaky-error");
 const get_browser_instance_1 = require("./helpers/get-browser-instance");
 const get_chromium_executable_path_1 = require("./helpers/get-chromium-executable-path");
 const get_current_region_1 = require("./helpers/get-current-region");
@@ -223,15 +224,9 @@ const rendererHandler = async (params, options) => {
             console.log({ err });
             throw err;
         }
-        const { message } = err;
         // If this error is encountered, we can just retry as it
         // is a very rare error to occur
-        const isRetryableError = message.includes('FATAL:zygote_communication_linux.cc') ||
-            message.includes('error while loading shared libraries: libnss3.so') ||
-            message.includes('but the server sent no data') ||
-            message.includes('Compositor panicked') ||
-            (message.includes('Compositor exited') && !message.includes('SIGSEGV')) ||
-            message.includes('Timed out while setting up the headless browser');
+        const isRetryableError = (0, is_flaky_error_1.isFlakyError)(err);
         const shouldNotRetry = err.name === 'CancelledError';
         const isFatal = !isRetryableError;
         const willRetry = isRetryableError && params.retriesLeft > 0 && !shouldNotRetry;
@@ -268,6 +263,7 @@ const rendererHandler = async (params, options) => {
                 region: (0, get_current_region_1.getCurrentRegionInFunction)(),
                 receivedStreamingPayload: () => undefined,
                 timeoutInTest: 120000,
+                retriesRemaining: 0,
             });
             return res;
         }

package/dist/functions/still.js

@@ -16,6 +16,7 @@ const cleanup_serialized_input_props_1 = require("../shared/cleanup-serialized-i
 const compress_props_1 = require("../shared/compress-props");
 const constants_1 = require("../shared/constants");
 const convert_to_serve_url_1 = require("../shared/convert-to-serve-url");
+const is_flaky_error_1 = require("../shared/is-flaky-error");
 const make_s3_url_1 = require("../shared/make-s3-url");
 const validate_download_behavior_1 = require("../shared/validate-download-behavior");
 const validate_outname_1 = require("../shared/validate-outname");
@@ -203,8 +204,7 @@ const stillHandler = async (options) => {
     catch (err) {
         // If this error is encountered, we can just retry as it
         // is a very rare error to occur
-        const isBrowserError = err.message.includes('FATAL:zygote_communication_linux.cc') ||
-            err.message.includes('error while loading shared libraries: libnss3.so');
+        const isBrowserError = (0, is_flaky_error_1.isFlakyError)(err);
         const willRetry = isBrowserError || params.maxRetries > 0;
         if (!willRetry) {
             throw err;
@@ -221,6 +221,7 @@ const stillHandler = async (options) => {
             type: constants_1.LambdaRoutines.still,
             receivedStreamingPayload: () => undefined,
             timeoutInTest: 120000,
+            retriesRemaining: 0,
         });
         const bucketName = (_a = params.bucketName) !== null && _a !== void 0 ? _a : (await (0, get_or_create_bucket_1.getOrCreateBucket)({
             region: (0, get_current_region_1.getCurrentRegionInFunction)(),

package/dist/shared/call-lambda.d.ts

@@ -2,11 +2,15 @@ import type { StreamingPayloads } from '../functions/helpers/streaming-payloads'
 import type { AwsRegion } from '../pricing/aws-regions';
 import type { LambdaPayloads, LambdaRoutines } from './constants';
 import type { LambdaReturnValues } from './return-values';
-export declare const callLambda: <T extends LambdaRoutines>({ functionName, type, payload, region, receivedStreamingPayload, timeoutInTest, }: {
+type Options<T extends LambdaRoutines> = {
     functionName: string;
     type: T;
-    payload: Omit<LambdaPayloads[T], "type">;
+    payload: Omit<LambdaPayloads[T], 'type'>;
     region: AwsRegion;
     receivedStreamingPayload: (streamPayload: StreamingPayloads) => void;
     timeoutInTest: number;
+};
+export declare const callLambda: <T extends LambdaRoutines>(options: Options<T> & {
+    retriesRemaining: number;
 }) => Promise<LambdaReturnValues[T]>;
+export {};

package/dist/shared/call-lambda.js

@@ -4,7 +4,30 @@ exports.callLambda = void 0;
 const client_lambda_1 = require("@aws-sdk/client-lambda");
 const streaming_payloads_1 = require("../functions/helpers/streaming-payloads");
 const aws_clients_1 = require("./aws-clients");
-const callLambda = async ({ functionName, type, payload, region, receivedStreamingPayload, timeoutInTest, }) => {
+const INVALID_JSON_MESSAGE = 'Cannot parse Lambda response as JSON';
+const callLambda = async (options) => {
+    // As of August 2023, Lambda streaming sometimes misses parts of the JSON response.
+    // Handling this for now by applying a retry mechanism.
+    try {
+        // Do not remove this await
+        const res = await callLambdaWithoutRetry(options);
+        return res;
+    }
+    catch (err) {
+        if (options.retriesRemaining === 0) {
+            throw err;
+        }
+        if (!err.message.includes(INVALID_JSON_MESSAGE)) {
+            throw err;
+        }
+        return (0, exports.callLambda)({
+            ...options,
+            retriesRemaining: options.retriesRemaining - 1,
+        });
+    }
+};
+exports.callLambda = callLambda;
+const callLambdaWithoutRetry = async ({ functionName, type, payload, region, receivedStreamingPayload, timeoutInTest, }) => {
     const res = await (0, aws_clients_1.getLambdaClient)(region, timeoutInTest).send(new client_lambda_1.InvokeWithResponseStreamCommand({
         FunctionName: functionName,
         Payload: JSON.stringify({ type, ...payload }),
@@ -38,13 +61,12 @@ const callLambda = async ({ functionName, type, payload, region, receivedStreami
     const json = parseJson(responsePayload.trim());
     return json;
 };
-exports.callLambda = callLambda;
 const parseJsonWithErrorSurfacing = (input) => {
     try {
         return JSON.parse(input);
     }
     catch (_a) {
-        throw new Error(`Cannot parse Lambda response as JSON. Response: ${input}`);
+        throw new Error(`${INVALID_JSON_MESSAGE}. Response: ${input}`);
     }
 };
 const parseJson = (input) => {

package/dist/shared/cleanup-serialized-input-props.d.ts

@@ -5,3 +5,8 @@ export declare const cleanupSerializedInputProps: ({ serialized, region, bucketN
     region: AwsRegion;
     bucketName: string;
 }) => Promise<number>;
+export declare const cleanupSerializedResolvedProps: ({ serialized, region, bucketName, }: {
+    serialized: SerializedInputProps;
+    region: AwsRegion;
+    bucketName: string;
+}) => Promise<number>;

package/dist/shared/cleanup-serialized-input-props.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cleanupSerializedInputProps = void 0;
+exports.cleanupSerializedResolvedProps = exports.cleanupSerializedInputProps = void 0;
 const io_1 = require("../functions/helpers/io");
 const constants_1 = require("./constants");
 const cleanupSerializedInputProps = async ({ serialized, region, bucketName, }) => {
@@ -17,3 +17,17 @@ const cleanupSerializedInputProps = async ({ serialized, region, bucketName, })
     return Date.now() - time;
 };
 exports.cleanupSerializedInputProps = cleanupSerializedInputProps;
+const cleanupSerializedResolvedProps = async ({ serialized, region, bucketName, }) => {
+    if (serialized.type === 'payload') {
+        return 0;
+    }
+    const time = Date.now();
+    await (0, io_1.lambdaDeleteFile)({
+        bucketName,
+        key: (0, constants_1.resolvedPropsKey)(serialized.hash),
+        region,
+        customCredentials: null,
+    });
+    return Date.now() - time;
+};
+exports.cleanupSerializedResolvedProps = cleanupSerializedResolvedProps;

package/dist/shared/deserialize-input-props.d.ts

@@ -0,0 +1,8 @@
+import type { AwsRegion } from '../client';
+import type { SerializedInputProps } from './constants';
+export declare const deserializeInputProps: ({ serialized, region, bucketName, expectedBucketOwner, }: {
+    serialized: SerializedInputProps;
+    region: AwsRegion;
+    bucketName: string;
+    expectedBucketOwner: string;
+}) => Promise<Record<string, unknown>>;

package/dist/shared/deserialize-input-props.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeInputProps = void 0;
+const io_1 = require("../functions/helpers/io");
+const constants_1 = require("./constants");
+const stream_to_string_1 = require("./stream-to-string");
+const deserializeInputProps = async ({ serialized, region, bucketName, expectedBucketOwner, }) => {
+    if (serialized.type === 'payload') {
+        return JSON.parse(serialized.payload);
+    }
+    try {
+        const response = await (0, io_1.lambdaReadFile)({
+            bucketName,
+            expectedBucketOwner,
+            key: (0, constants_1.inputPropsKey)(serialized.hash),
+            region,
+        });
+        const body = await (0, stream_to_string_1.streamToString)(response);
+        const payload = JSON.parse(body);
+        return payload;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse input props that were serialized: ${err.stack}`);
+    }
+};
+exports.deserializeInputProps = deserializeInputProps;

package/dist/shared/get-function-version.js

@@ -14,6 +14,7 @@ const getFunctionVersion = async ({ functionName, region, }) => {
             type: constants_1.LambdaRoutines.info,
             receivedStreamingPayload: () => undefined,
             timeoutInTest: 120000,
+            retriesRemaining: 0,
         });
         return result.version;
     }

package/dist/shared/is-flaky-error.d.ts

@@ -0,0 +1 @@
+export declare const isFlakyError: (err: Error) => boolean;

package/dist/shared/is-flaky-error.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFlakyError = void 0;
+const isFlakyError = (err) => {
+    const { message } = err;
+    // storage.googleapis.com sometimes returns 500s, and Video does not have retry on its own
+    if ((message.includes('Format error') || message.includes('audio metadata')) &&
+        message.includes('storage.googleapis.com')) {
+        return true;
+    }
+    if (message.includes('FATAL:zygote_communication_linux.cc')) {
+        return true;
+    }
+    if (message.includes('error while loading shared libraries: libnss3.so')) {
+        return true;
+    }
+    if (message.includes('but the server sent no data')) {
+        return true;
+    }
+    if (message.includes('Compositor panicked')) {
+        return true;
+    }
+    if (message.includes('Compositor exited') && !message.includes('SIGSEGV')) {
+        return true;
+    }
+    if (message.includes('Timed out while setting up the headless browser')) {
+        return true;
+    }
+    return false;
+};
+exports.isFlakyError = isFlakyError;

package/dist/shared/serialize-input-props.d.ts

@@ -0,0 +1,14 @@
+import type { AwsRegion } from '../client';
+import type { SerializedInputProps } from './constants';
+export declare const serializeInputProps: ({ inputProps, region, type, userSpecifiedBucketName, }: {
+    inputProps: Record<string, unknown>;
+    region: AwsRegion;
+    type: 'still' | 'video-or-audio';
+    userSpecifiedBucketName: string | null;
+}) => Promise<SerializedInputProps>;
+export declare const deserializeInputProps: ({ serialized, region, bucketName, expectedBucketOwner, }: {
+    serialized: SerializedInputProps;
+    region: AwsRegion;
+    bucketName: string;
+    expectedBucketOwner: string;
+}) => Promise<Record<string, unknown>>;

package/dist/shared/serialize-input-props.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeInputProps = exports.serializeInputProps = void 0;
+const get_or_create_bucket_1 = require("../api/get-or-create-bucket");
+const io_1 = require("../functions/helpers/io");
+const constants_1 = require("./constants");
+const random_hash_1 = require("./random-hash");
+const stream_to_string_1 = require("./stream-to-string");
+const serializeInputProps = async ({ inputProps, region, type, userSpecifiedBucketName, }) => {
+    try {
+        const payload = JSON.stringify(inputProps);
+        const hash = (0, random_hash_1.randomHash)();
+        const MAX_INLINE_PAYLOAD_SIZE = type === 'still' ? 5000000 : 200000;
+        if (payload.length > MAX_INLINE_PAYLOAD_SIZE) {
+            console.warn(`Warning: inputProps are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(payload.length / 1024)}KB) in size. Uploading them to S3 to circumvent AWS Lambda payload size.`);
+            const bucketName = userSpecifiedBucketName !== null && userSpecifiedBucketName !== void 0 ? userSpecifiedBucketName : (await (0, get_or_create_bucket_1.getOrCreateBucket)({
+                region,
+            })).bucketName;
+            await (0, io_1.lambdaWriteFile)({
+                body: payload,
+                bucketName,
+                region,
+                customCredentials: null,
+                downloadBehavior: null,
+                expectedBucketOwner: null,
+                key: (0, constants_1.inputPropsKey)(hash),
+                privacy: 'public',
+            });
+            return {
+                type: 'bucket-url',
+                hash,
+            };
+        }
+        return {
+            type: 'payload',
+            payload,
+        };
+    }
+    catch (err) {
+        throw new Error('Error serializing inputProps. Check it has no circular references or reduce the size if the object is big.');
+    }
+};
+exports.serializeInputProps = serializeInputProps;
+const deserializeInputProps = async ({ serialized, region, bucketName, expectedBucketOwner, }) => {
+    if (serialized.type === 'payload') {
+        return JSON.parse(serialized.payload);
+    }
+    try {
+        const response = await (0, io_1.lambdaReadFile)({
+            bucketName,
+            expectedBucketOwner,
+            key: (0, constants_1.inputPropsKey)(serialized.hash),
+            region,
+        });
+        const body = await (0, stream_to_string_1.streamToString)(response);
+        const payload = JSON.parse(body);
+        return payload;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse input props that were serialized: ${err.stack}`);
+    }
+};
+exports.deserializeInputProps = deserializeInputProps;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/lambda",
-  "version": "4.0.16",
+  "version": "4.0.18",
   "description": "Distributed renderer for Remotion based on AWS Lambda",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -26,10 +26,10 @@
     "aws-policies": "^1.0.1",
     "mime-types": "2.1.34",
     "zod": "3.21.4",
-    "@remotion/bundler": "4.0.16",
-    "@remotion/cli": "4.0.16",
-    "@remotion/renderer": "4.0.16",
-    "remotion": "4.0.16"
+    "@remotion/bundler": "4.0.18",
+    "@remotion/cli": "4.0.18",
+    "remotion": "4.0.18",
+    "@remotion/renderer": "4.0.18"
   },
   "devDependencies": {
     "@jonny/eslint-config": "3.0.266",
@@ -41,14 +41,13 @@
     "prettier": "^2.4.1",
     "prettier-plugin-organize-imports": "^3.2.2",
     "ts-node": "^10.8.0",
-    "typescript": "4.9.5",
     "vitest": "0.31.1",
     "zip-lib": "^0.7.2",
-    "@remotion/bundler": "4.0.16",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.16"
+    "@remotion/bundler": "4.0.18",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.18"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.16"
+    "@remotion/bundler": "4.0.18"
   },
   "publishConfig": {
     "access": "public"