@remotion/lambda 4.0.43 → 4.0.45

package/dist/functions/helpers/get-progress.js

@@ -4,6 +4,7 @@ exports.getProgress = void 0;
 const renderer_1 = require("@remotion/renderer");
 const remotion_1 = require("remotion");
 const constants_1 = require("../../shared/constants");
+const parse_chunk_key_1 = require("../../shared/parse-chunk-key");
 const calculate_chunk_times_1 = require("./calculate-chunk-times");
 const calculate_price_from_bucket_1 = require("./calculate-price-from-bucket");
 const check_if_render_exists_1 = require("./check-if-render-exists");
@@ -167,16 +168,32 @@ const getProgress = async ({ bucketName, renderId, expectedBucketOwner, region,
     const chunkCount = outputFile
         ? (_g = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.totalChunks) !== null && _g !== void 0 ? _g : 0
         : chunks.length;
+    const availableChunks = chunks.map((c) => (0, parse_chunk_key_1.parseLambdaChunkKey)(c.Key));
+    const missingChunks = renderMetadata
+        ? new Array(renderMetadata.totalChunks)
+            .fill(true)
+            .map((_, i) => i)
+            .filter((index) => {
+            return !availableChunks.find((c) => c.chunk === index);
+        })
+        : null;
     // We add a 20 second buffer for it, since AWS timeshifts can be quite a lot. Once it's 20sec over the limit, we consider it timed out
-    const isBeyondTimeout = renderMetadata &&
-        Date.now() > renderMetadata.startedDate + timeoutInMilliseconds + 20000;
+    // 1. If we have missing chunks, we consider it timed out
+    const isBeyondTimeoutAndMissingChunks = renderMetadata &&
+        Date.now() > renderMetadata.startedDate + timeoutInMilliseconds + 20000 &&
+        missingChunks &&
+        missingChunks.length > 0;
+    // 2. If we have no missing chunks, but the encoding is not done, even after the additional `merge` function has been spawned, we consider it timed out
+    const isBeyondTimeoutAndHasStitchTimeout = renderMetadata &&
+        Date.now() > renderMetadata.startedDate + timeoutInMilliseconds * 2 + 20000;
     const allErrors = [
-        isBeyondTimeout
+        isBeyondTimeoutAndMissingChunks || isBeyondTimeoutAndHasStitchTimeout
             ? (0, make_timeout_error_1.makeTimeoutError)({
                 timeoutInMilliseconds,
                 renderMetadata,
                 chunks,
                 renderId,
+                missingChunks: missingChunks !== null && missingChunks !== void 0 ? missingChunks : [],
             })
             : null,
         ...errorExplanations,

package/dist/functions/helpers/make-timeout-error.d.ts

@@ -1,9 +1,10 @@
 import type { _Object } from '@aws-sdk/client-s3';
 import type { RenderMetadata } from '../../defaults';
 import type { EnhancedErrorInfo } from './write-lambda-error';
-export declare const makeTimeoutError: ({ timeoutInMilliseconds, chunks, renderMetadata, renderId, }: {
+export declare const makeTimeoutError: ({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, }: {
     timeoutInMilliseconds: number;
     chunks: _Object[];
     renderMetadata: RenderMetadata;
     renderId: string;
+    missingChunks: number[];
 }) => EnhancedErrorInfo;

package/dist/functions/helpers/make-timeout-error.js

@@ -1,16 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTimeoutError = void 0;
-const parse_chunk_key_1 = require("../../shared/parse-chunk-key");
 const make_timeout_message_1 = require("./make-timeout-message");
-const makeTimeoutError = ({ timeoutInMilliseconds, chunks, renderMetadata, renderId, }) => {
-    const availableChunks = chunks.map((c) => (0, parse_chunk_key_1.parseLambdaChunkKey)(c.Key));
-    const missingChunks = new Array(renderMetadata.totalChunks)
-        .fill(true)
-        .map((_, i) => i)
-        .filter((index) => {
-        return !availableChunks.find((c) => c.chunk === index);
-    });
+const makeTimeoutError = ({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, }) => {
     const message = (0, make_timeout_message_1.makeTimeoutMessage)({
         missingChunks,
         renderMetadata,

package/dist/functions/helpers/merge-chunks.d.ts

@@ -0,0 +1,30 @@
+import type { AudioCodec } from '@remotion/renderer';
+import type { CustomCredentials } from '../../shared/aws-clients';
+import type { PostRenderData, Privacy, RenderMetadata, SerializedInputProps } from '../../shared/constants';
+import type { DownloadBehavior } from '../../shared/content-disposition-header';
+import type { LambdaCodec } from '../../shared/validate-lambda-codec';
+export type OnAllChunksAvailable = (options: {
+    inputProps: SerializedInputProps;
+    serializedResolvedProps: SerializedInputProps;
+}) => void;
+export declare const mergeChunksAndFinishRender: (options: {
+    bucketName: string;
+    renderId: string;
+    expectedBucketOwner: string;
+    frameCountLength: number;
+    codec: LambdaCodec;
+    chunkCount: number;
+    fps: number;
+    numberOfGifLoops: number | null;
+    audioCodec: AudioCodec | null;
+    renderBucketName: string;
+    customCredentials: CustomCredentials | null;
+    downloadBehavior: DownloadBehavior;
+    key: string;
+    privacy: Privacy;
+    inputProps: SerializedInputProps;
+    verbose: boolean;
+    serializedResolvedProps: SerializedInputProps;
+    renderMetadata: RenderMetadata;
+    onAllChunks: OnAllChunksAvailable;
+}) => Promise<PostRenderData>;

package/dist/functions/helpers/merge-chunks.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeChunksAndFinishRender = void 0;
+const renderer_1 = require("@remotion/renderer");
+const fs_1 = __importDefault(require("fs"));
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const cleanup_serialized_input_props_1 = require("../../shared/cleanup-serialized-input-props");
+const constants_1 = require("../../shared/constants");
+const concat_videos_1 = require("./concat-videos");
+const create_post_render_data_1 = require("./create-post-render-data");
+const delete_chunks_1 = require("./delete-chunks");
+const get_current_region_1 = require("./get-current-region");
+const get_files_to_delete_1 = require("./get-files-to-delete");
+const get_output_url_from_metadata_1 = require("./get-output-url-from-metadata");
+const inspect_errors_1 = require("./inspect-errors");
+const io_1 = require("./io");
+const write_lambda_error_1 = require("./write-lambda-error");
+const write_post_render_data_1 = require("./write-post-render-data");
+const mergeChunksAndFinishRender = async (options) => {
+    let lastProgressUploaded = 0;
+    const onProgress = (framesEncoded) => {
+        const relativeProgress = framesEncoded / options.frameCountLength;
+        const deltaSinceLastProgressUploaded = relativeProgress - lastProgressUploaded;
+        if (deltaSinceLastProgressUploaded < 0.1) {
+            return;
+        }
+        lastProgressUploaded = relativeProgress;
+        (0, io_1.lambdaWriteFile)({
+            bucketName: options.bucketName,
+            key: (0, constants_1.encodingProgressKey)(options.renderId),
+            body: String(Math.round(framesEncoded / constants_1.ENCODING_PROGRESS_STEP_SIZE)),
+            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            privacy: 'private',
+            expectedBucketOwner: options.expectedBucketOwner,
+            downloadBehavior: null,
+            customCredentials: null,
+        }).catch((err) => {
+            (0, write_lambda_error_1.writeLambdaError)({
+                bucketName: options.bucketName,
+                errorInfo: {
+                    chunk: null,
+                    frame: null,
+                    isFatal: false,
+                    name: err.name,
+                    message: err.message,
+                    stack: `Could not upload stitching progress ${err.stack}`,
+                    tmpDir: null,
+                    type: 'stitcher',
+                    attempt: 1,
+                    totalAttempts: 1,
+                    willRetry: false,
+                },
+                renderId: options.renderId,
+                expectedBucketOwner: options.expectedBucketOwner,
+            });
+        });
+    };
+    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
+                .split('\n')
+                .map((s) => `   ${s}`)
+                .join('\n')}`);
+        }
+        throw new Error(`Stopping Lambda function because error occurred: ${errors[0].stack}`);
+    };
+    const outdir = (0, node_path_1.join)(renderer_1.RenderInternals.tmpDir(constants_1.CONCAT_FOLDER_TOKEN), 'bucket');
+    if ((0, node_fs_1.existsSync)(outdir)) {
+        (0, node_fs_1.rmSync)(outdir, {
+            recursive: true,
+        });
+    }
+    (0, node_fs_1.mkdirSync)(outdir);
+    const files = await (0, concat_videos_1.getAllFilesS3)({
+        bucket: options.bucketName,
+        expectedFiles: options.chunkCount,
+        outdir,
+        renderId: options.renderId,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        expectedBucketOwner: options.expectedBucketOwner,
+        onErrors,
+    });
+    options.onAllChunks({
+        inputProps: options.inputProps,
+        serializedResolvedProps: options.serializedResolvedProps,
+    });
+    const encodingStart = Date.now();
+    const { outfile, cleanupChunksProm } = await (0, concat_videos_1.concatVideosS3)({
+        onProgress,
+        numberOfFrames: options.frameCountLength,
+        codec: options.codec,
+        fps: options.fps,
+        numberOfGifLoops: options.numberOfGifLoops,
+        files,
+        outdir,
+        audioCodec: options.audioCodec,
+    });
+    const encodingStop = Date.now();
+    const outputSize = fs_1.default.statSync(outfile);
+    await (0, io_1.lambdaWriteFile)({
+        bucketName: options.renderBucketName,
+        key: options.key,
+        body: fs_1.default.createReadStream(outfile),
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        privacy: options.privacy,
+        expectedBucketOwner: options.expectedBucketOwner,
+        downloadBehavior: options.downloadBehavior,
+        customCredentials: options.customCredentials,
+    });
+    const contents = await (0, io_1.lambdaLs)({
+        bucketName: options.bucketName,
+        prefix: (0, constants_1.rendersPrefix)(options.renderId),
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+    });
+    const finalEncodingProgressProm = (0, io_1.lambdaWriteFile)({
+        bucketName: options.bucketName,
+        key: (0, constants_1.encodingProgressKey)(options.renderId),
+        body: String(Math.ceil(options.frameCountLength / constants_1.ENCODING_PROGRESS_STEP_SIZE)),
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        privacy: 'private',
+        expectedBucketOwner: options.expectedBucketOwner,
+        downloadBehavior: null,
+        customCredentials: null,
+    });
+    const errorExplanationsProm = (0, inspect_errors_1.inspectErrors)({
+        contents,
+        renderId: options.renderId,
+        bucket: options.bucketName,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        expectedBucketOwner: options.expectedBucketOwner,
+    });
+    const jobs = (0, get_files_to_delete_1.getFilesToDelete)({
+        chunkCount: options.chunkCount,
+        renderId: options.renderId,
+    });
+    const deletProm = options.verbose
+        ? Promise.resolve(0)
+        : (0, delete_chunks_1.cleanupFiles)({
+            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            bucket: options.bucketName,
+            contents,
+            jobs,
+        });
+    const cleanupSerializedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
+        bucketName: options.bucketName,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        serialized: options.inputProps,
+    });
+    const cleanupResolvedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedResolvedProps)({
+        bucketName: options.bucketName,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        serialized: options.serializedResolvedProps,
+    });
+    const outputUrl = (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(options.renderMetadata, options.bucketName, options.customCredentials);
+    const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        renderId: options.renderId,
+        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+        renderMetadata: options.renderMetadata,
+        contents,
+        errorExplanations: await errorExplanationsProm,
+        timeToEncode: encodingStop - encodingStart,
+        timeToDelete: (await Promise.all([
+            deletProm,
+            cleanupSerializedInputPropsProm,
+            cleanupResolvedInputPropsProm,
+        ])).reduce((a, b) => a + b, 0),
+        outputFile: {
+            lastModified: Date.now(),
+            size: outputSize.size,
+            url: outputUrl,
+        },
+    });
+    await finalEncodingProgressProm;
+    await (0, write_post_render_data_1.writePostRenderData)({
+        bucketName: options.bucketName,
+        expectedBucketOwner: options.expectedBucketOwner,
+        postRenderData,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        renderId: options.renderId,
+    });
+    await (0, io_1.lambdaDeleteFile)({
+        bucketName: options.bucketName,
+        key: (0, constants_1.initalizedMetadataKey)(options.renderId),
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        customCredentials: null,
+    });
+    await Promise.all([cleanupChunksProm, fs_1.default.promises.rm(outfile)]);
+    return postRenderData;
+};
+exports.mergeChunksAndFinishRender = mergeChunksAndFinishRender;

package/dist/functions/index.js

@@ -12,6 +12,7 @@ const streamify_response_1 = require("./helpers/streamify-response");
 const streaming_payloads_1 = require("./helpers/streaming-payloads");
 const info_1 = require("./info");
 const launch_1 = require("./launch");
+const merge_1 = require("./merge");
 const progress_1 = require("./progress");
 const renderer_2 = require("./renderer");
 const start_1 = require("./start");
@@ -123,6 +124,19 @@ const innerHandler = async (params, responseStream, context) => {
         });
         return;
     }
+    if (params.type === constants_1.LambdaRoutines.merge) {
+        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.merge, {
+            renderId: params.renderId,
+            isWarm,
+        });
+        renderer_1.RenderInternals.setLogLevel(params.logLevel);
+        const response = await (0, merge_1.mergeHandler)(params, {
+            expectedBucketOwner: currentUserId,
+        });
+        responseStream.write(JSON.stringify(response), () => {
+            responseStream.end();
+        });
+    }
     if (params.type === constants_1.LambdaRoutines.compositions) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.compositions, {
             isWarm,

package/dist/functions/launch.js

@@ -1,39 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.launchHandler = void 0;
 const client_lambda_1 = require("@aws-sdk/client-lambda");
 const renderer_1 = require("@remotion/renderer");
-const node_fs_1 = __importStar(require("node:fs"));
-const node_path_1 = require("node:path");
 const version_1 = require("remotion/version");
 const aws_clients_1 = require("../shared/aws-clients");
-const cleanup_serialized_input_props_1 = require("../shared/cleanup-serialized-input-props");
 const compress_props_1 = require("../shared/compress-props");
 const constants_1 = require("../shared/constants");
 const docs_url_1 = require("../shared/docs-url");
+const get_aws_urls_1 = require("../shared/get-aws-urls");
 const invoke_webhook_1 = require("../shared/invoke-webhook");
 const validate_1 = require("../shared/validate");
 const validate_frames_per_lambda_1 = require("../shared/validate-frames-per-lambda");
@@ -41,21 +16,15 @@ const validate_outname_1 = require("../shared/validate-outname");
 const validate_privacy_1 = require("../shared/validate-privacy");
 const plan_frame_ranges_1 = require("./chunk-optimization/plan-frame-ranges");
 const best_frames_per_lambda_param_1 = require("./helpers/best-frames-per-lambda-param");
-const concat_videos_1 = require("./helpers/concat-videos");
-const create_post_render_data_1 = require("./helpers/create-post-render-data");
-const delete_chunks_1 = require("./helpers/delete-chunks");
 const expected_out_name_1 = require("./helpers/expected-out-name");
 const find_output_file_in_bucket_1 = require("./helpers/find-output-file-in-bucket");
 const get_browser_instance_1 = require("./helpers/get-browser-instance");
 const get_current_region_1 = require("./helpers/get-current-region");
-const get_files_to_delete_1 = require("./helpers/get-files-to-delete");
-const get_output_url_from_metadata_1 = require("./helpers/get-output-url-from-metadata");
-const inspect_errors_1 = require("./helpers/inspect-errors");
 const io_1 = require("./helpers/io");
+const merge_chunks_1 = require("./helpers/merge-chunks");
 const timer_1 = require("./helpers/timer");
 const validate_composition_1 = require("./helpers/validate-composition");
 const write_lambda_error_1 = require("./helpers/write-lambda-error");
-const write_post_render_data_1 = require("./helpers/write-post-render-data");
 const callFunctionWithRetry = async ({ payload, retries, functionName, }) => {
     try {
         await (0, aws_clients_1.getLambdaClient)((0, get_current_region_1.getCurrentRegionInFunction)()).send(new client_lambda_1.InvokeCommand({
@@ -81,14 +50,12 @@ const callFunctionWithRetry = async ({ payload, retries, functionName, }) => {
         throw err;
     }
 };
-const innerLaunchHandler = async (params, options) => {
-    var _a, _b, _c, _d, _e, _f;
+const innerLaunchHandler = async ({ functionName, params, options, onAllChunksAvailable, verbose, }) => {
+    var _a, _b, _c, _d, _e;
     if (params.type !== constants_1.LambdaRoutines.launch) {
         throw new Error('Expected launch type');
     }
-    const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : process.env.AWS_LAMBDA_FUNCTION_NAME;
     const startedDate = Date.now();
-    const verbose = renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose');
     const browserInstance = await (0, get_browser_instance_1.getBrowserInstance)(params.logLevel, false, params.chromiumOptions);
     const inputPropsPromise = (0, compress_props_1.decompressInputProps)({
         bucketName: params.bucketName,
@@ -104,7 +71,7 @@ const innerLaunchHandler = async (params, options) => {
         composition: params.composition,
         browserInstance,
         serializedInputPropsWithCustomSchema,
-        envVariables: (_b = params.envVariables) !== null && _b !== void 0 ? _b : {},
+        envVariables: (_a = params.envVariables) !== null && _a !== void 0 ? _a : {},
         timeoutInMilliseconds: params.timeoutInMilliseconds,
         chromiumOptions: params.chromiumOptions,
         port: null,
@@ -131,15 +98,11 @@ const innerLaunchHandler = async (params, options) => {
     });
     const realFrameRange = renderer_1.RenderInternals.getRealFrameRange(comp.durationInFrames, params.frameRange);
     const frameCount = renderer_1.RenderInternals.getFramesToRender(realFrameRange, params.everyNthFrame);
-    const framesPerLambda = (_c = params.framesPerLambda) !== null && _c !== void 0 ? _c : (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(frameCount.length);
+    const framesPerLambda = (_b = params.framesPerLambda) !== null && _b !== void 0 ? _b : (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(frameCount.length);
     (0, validate_frames_per_lambda_1.validateFramesPerLambda)({
         framesPerLambda,
         durationInFrames: frameCount.length,
     });
-    const chunkCount = Math.ceil(frameCount.length / framesPerLambda);
-    if (chunkCount > constants_1.MAX_FUNCTIONS_PER_RENDER) {
-        throw new Error(`Too many functions: This render would cause ${chunkCount} functions to spawn. We limit this amount to ${constants_1.MAX_FUNCTIONS_PER_RENDER} functions as more would result in diminishing returns. Values set: frameCount = ${frameCount}, framesPerLambda=${framesPerLambda}. See ${docs_url_1.DOCS_URL}/docs/lambda/concurrency#too-many-functions for help.`);
-    }
     (0, validate_outname_1.validateOutname)(params.outName, params.codec, params.audioCodec);
     (0, validate_privacy_1.validatePrivacy)(params.privacy, true);
     renderer_1.RenderInternals.validatePuppeteerTimeout(params.timeoutInMilliseconds);
@@ -148,6 +111,9 @@ const innerLaunchHandler = async (params, options) => {
         frameRange: realFrameRange,
         everyNthFrame: params.everyNthFrame,
     });
+    if (chunks.length > constants_1.MAX_FUNCTIONS_PER_RENDER) {
+        throw new Error(`Too many functions: This render would cause ${chunks.length} functions to spawn. We limit this amount to ${constants_1.MAX_FUNCTIONS_PER_RENDER} functions as more would result in diminishing returns. Values set: frameCount = ${frameCount}, framesPerLambda=${framesPerLambda}. See ${docs_url_1.DOCS_URL}/docs/lambda/concurrency#too-many-functions for help.`);
+    }
     const sortedChunks = chunks.slice().sort((a, b) => a[0] - b[0]);
     const reqSend = (0, timer_1.timer)('sending off requests');
     const serializedResolved = (0, compress_props_1.serializeOrThrow)(comp.props, 'resolved-props');
@@ -232,16 +198,18 @@ const innerLaunchHandler = async (params, options) => {
         memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         renderId: params.renderId,
-        outName: (_d = params.outName) !== null && _d !== void 0 ? _d : undefined,
+        outName: (_c = params.outName) !== null && _c !== void 0 ? _c : undefined,
         privacy: params.privacy,
         everyNthFrame: params.everyNthFrame,
         frameRange: realFrameRange,
         audioCodec: params.audioCodec,
         deleteAfter: params.deleteAfter,
+        numberOfGifLoops: params.numberOfGifLoops,
+        downloadBehavior: params.downloadBehavior,
     };
     const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
         ? null
-        : (_f = (_e = params.outName) === null || _e === void 0 ? void 0 : _e.s3OutputProvider) !== null && _f !== void 0 ? _f : null);
+        : (_e = (_d = params.outName) === null || _d === void 0 ? void 0 : _d.s3OutputProvider) !== null && _e !== void 0 ? _e : null);
     const output = await (0, find_output_file_in_bucket_1.findOutputFileInBucket)({
         bucketName: params.bucketName,
         customCredentials,
@@ -276,209 +244,78 @@ const innerLaunchHandler = async (params, options) => {
         await callFunctionWithRetry({ payload, retries: 0, functionName });
     }));
     reqSend.end();
-    let lastProgressUploaded = 0;
-    const onProgress = (framesEncoded) => {
-        const relativeProgress = framesEncoded / frameCount.length;
-        const deltaSinceLastProgressUploaded = relativeProgress - lastProgressUploaded;
-        if (deltaSinceLastProgressUploaded < 0.1) {
-            return;
-        }
-        lastProgressUploaded = relativeProgress;
-        (0, io_1.lambdaWriteFile)({
-            bucketName: params.bucketName,
-            key: (0, constants_1.encodingProgressKey)(params.renderId),
-            body: String(Math.round(framesEncoded / constants_1.ENCODING_PROGRESS_STEP_SIZE)),
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            privacy: 'private',
-            expectedBucketOwner: options.expectedBucketOwner,
-            downloadBehavior: null,
-            customCredentials: null,
-        }).catch((err) => {
-            (0, write_lambda_error_1.writeLambdaError)({
-                bucketName: params.bucketName,
-                errorInfo: {
-                    chunk: null,
-                    frame: null,
-                    isFatal: false,
-                    name: err.name,
-                    message: err.message,
-                    stack: `Could not upload stitching progress ${err.stack}`,
-                    tmpDir: null,
-                    type: 'stitcher',
-                    attempt: 1,
-                    totalAttempts: 1,
-                    willRetry: false,
-                },
-                renderId: params.renderId,
-                expectedBucketOwner: options.expectedBucketOwner,
-            });
-        });
-    };
-    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
-                .split('\n')
-                .map((s) => `   ${s}`)
-                .join('\n')}`);
-        }
-        throw new Error(`Stopping Lambda function because error occurred: ${errors[0].stack}`);
-    };
     const fps = comp.fps / params.everyNthFrame;
-    const outdir = (0, node_path_1.join)(renderer_1.RenderInternals.tmpDir(constants_1.CONCAT_FOLDER_TOKEN), 'bucket');
-    if ((0, node_fs_1.existsSync)(outdir)) {
-        (0, node_fs_1.rmSync)(outdir, {
-            recursive: true,
-        });
-    }
-    (0, node_fs_1.mkdirSync)(outdir);
-    const files = await (0, concat_videos_1.getAllFilesS3)({
-        bucket: params.bucketName,
-        expectedFiles: chunkCount,
-        outdir,
+    const postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
+        bucketName: params.bucketName,
         renderId: params.renderId,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         expectedBucketOwner: options.expectedBucketOwner,
-        onErrors,
-    });
-    const encodingStart = Date.now();
-    const { outfile, cleanupChunksProm } = await (0, concat_videos_1.concatVideosS3)({
-        onProgress,
-        numberOfFrames: frameCount.length,
+        frameCountLength: frameCount.length,
+        audioCodec: params.audioCodec,
+        chunkCount: chunks.length,
         codec: params.codec,
+        customCredentials,
+        downloadBehavior: params.downloadBehavior,
         fps,
-        numberOfGifLoops: params.numberOfGifLoops,
-        files,
-        outdir,
-        audioCodec: params.audioCodec,
-    });
-    const encodingStop = Date.now();
-    const outputSize = node_fs_1.default.statSync(outfile);
-    await (0, io_1.lambdaWriteFile)({
-        bucketName: renderBucketName,
         key,
-        body: node_fs_1.default.createReadStream(outfile),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        numberOfGifLoops: params.numberOfGifLoops,
         privacy: params.privacy,
-        expectedBucketOwner: options.expectedBucketOwner,
-        downloadBehavior: params.downloadBehavior,
-        customCredentials,
-    });
-    const contents = await (0, io_1.lambdaLs)({
-        bucketName: params.bucketName,
-        prefix: (0, constants_1.rendersPrefix)(params.renderId),
-        expectedBucketOwner: options.expectedBucketOwner,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-    });
-    const finalEncodingProgressProm = (0, io_1.lambdaWriteFile)({
-        bucketName: params.bucketName,
-        key: (0, constants_1.encodingProgressKey)(params.renderId),
-        body: String(Math.ceil(frameCount.length / constants_1.ENCODING_PROGRESS_STEP_SIZE)),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        privacy: 'private',
-        expectedBucketOwner: options.expectedBucketOwner,
-        downloadBehavior: null,
-        customCredentials: null,
-    });
-    const errorExplanationsProm = (0, inspect_errors_1.inspectErrors)({
-        contents,
-        renderId: params.renderId,
-        bucket: params.bucketName,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        expectedBucketOwner: options.expectedBucketOwner,
-    });
-    const jobs = (0, get_files_to_delete_1.getFilesToDelete)({
-        chunkCount,
-        renderId: params.renderId,
-    });
-    const deletProm = verbose
-        ? Promise.resolve(0)
-        : (0, delete_chunks_1.cleanupFiles)({
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            bucket: params.bucketName,
-            contents,
-            jobs,
-        });
-    const cleanupSerializedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
-        bucketName: params.bucketName,
-        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,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        renderId: params.renderId,
-        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+        renderBucketName,
+        inputProps: params.inputProps,
+        serializedResolvedProps,
+        verbose,
         renderMetadata,
-        contents,
-        errorExplanations: await errorExplanationsProm,
-        timeToEncode: encodingStop - encodingStart,
-        timeToDelete: (await Promise.all([
-            deletProm,
-            cleanupSerializedInputPropsProm,
-            cleanupResolvedInputPropsProm,
-        ])).reduce((a, b) => a + b, 0),
-        outputFile: {
-            lastModified: Date.now(),
-            size: outputSize.size,
-            url: outputUrl,
-        },
+        onAllChunks: onAllChunksAvailable,
     });
-    await finalEncodingProgressProm;
-    await (0, write_post_render_data_1.writePostRenderData)({
-        bucketName: params.bucketName,
-        expectedBucketOwner: options.expectedBucketOwner,
-        postRenderData,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        renderId: params.renderId,
-    });
-    await (0, io_1.lambdaDeleteFile)({
-        bucketName: params.bucketName,
-        key: (0, constants_1.initalizedMetadataKey)(params.renderId),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        customCredentials: null,
-    });
-    await Promise.all([cleanupChunksProm, node_fs_1.default.promises.rm(outfile)]);
     return postRenderData;
 };
 const launchHandler = async (params, options) => {
-    var _a, _b;
+    var _a, _b, _c;
     if (params.type !== constants_1.LambdaRoutines.launch) {
         throw new Error('Expected launch type');
     }
-    let webhookInvoked = false;
-    const webhookDueToTimeout = setTimeout(async () => {
+    let allChunksAvailable = null;
+    const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : process.env.AWS_LAMBDA_FUNCTION_NAME;
+    const verbose = renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose');
+    const onTimeout = async () => {
         var _a;
-        if (params.webhook && !webhookInvoked) {
+        if (allChunksAvailable) {
+            renderer_1.RenderInternals.Log.info('All chunks are available, but the function is about to time out.');
+            renderer_1.RenderInternals.Log.info('Spawning another function to merge chunks.');
             try {
-                await (0, invoke_webhook_1.invokeWebhook)({
-                    url: params.webhook.url,
-                    secret: params.webhook.secret,
+                await callFunctionWithRetry({
+                    functionName,
                     payload: {
-                        type: 'timeout',
+                        type: constants_1.LambdaRoutines.merge,
                         renderId: params.renderId,
-                        expectedBucketOwner: options.expectedBucketOwner,
                         bucketName: params.bucketName,
-                        customData: (_a = params.webhook.customData) !== null && _a !== void 0 ? _a : null,
+                        verbose,
+                        outName: params.outName,
+                        serializedResolvedProps: allChunksAvailable.serializedResolvedProps,
+                        inputProps: allChunksAvailable.inputProps,
+                        logLevel: params.logLevel,
                     },
+                    retries: 2,
                 });
-                webhookInvoked = true;
+                renderer_1.RenderInternals.Log.info(`New function successfully invoked. See the CloudWatch logs for it:`);
+                renderer_1.RenderInternals.Log.info((0, get_aws_urls_1.getCloudwatchMethodUrl)({
+                    functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+                    method: constants_1.LambdaRoutines.merge,
+                    region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+                    rendererFunctionName: params.rendererFunctionName,
+                    renderId: params.renderId,
+                }));
+                renderer_1.RenderInternals.Log.info('This function will now time out.');
             }
             catch (err) {
                 if (process.env.NODE_ENV === 'test') {
                     throw err;
                 }
+                renderer_1.RenderInternals.Log.error('Failed to invoke additional function to merge videos:');
+                renderer_1.RenderInternals.Log.error(err);
                 await (0, write_lambda_error_1.writeLambdaError)({
                     bucketName: params.bucketName,
                     errorInfo: {
-                        type: 'webhook',
+                        type: 'stitcher',
                         message: err.message,
                         name: err.name,
                         stack: err.stack,
@@ -493,60 +330,116 @@ const launchHandler = async (params, options) => {
                     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));
+        if (!params.webhook) {
+            return;
+        }
+        if (webhookInvoked) {
+            return;
+        }
+        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,
+                    customData: (_a = params.webhook.customData) !== null && _a !== void 0 ? _a : null,
+                },
+            });
+            webhookInvoked = true;
+        }
+        catch (err) {
+            if (process.env.NODE_ENV === 'test') {
+                throw err;
+            }
+            renderer_1.RenderInternals.Log.error('Failed to invoke webhook:');
+            renderer_1.RenderInternals.Log.error(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,
+            });
+        }
+    };
+    let webhookInvoked = false;
+    const webhookDueToTimeout = setTimeout(onTimeout, Math.max(options.getRemainingTimeInMillis() - 1000, 1000));
     renderer_1.RenderInternals.Log.info(`Function has ${Math.max(options.getRemainingTimeInMillis() - 1000, 1000)} before it times out`);
     try {
-        const postRenderData = await innerLaunchHandler(params, options);
+        const postRenderData = await innerLaunchHandler({
+            functionName,
+            params,
+            options,
+            onAllChunksAvailable: ({ inputProps, serializedResolvedProps }) => {
+                allChunksAvailable = { inputProps, serializedResolvedProps };
+            },
+            verbose,
+        });
         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,
-                        customData: (_a = params.webhook.customData) !== null && _a !== void 0 ? _a : null,
-                        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,
-                    },
+        if (!params.webhook || webhookInvoked) {
+            return {
+                type: 'success',
+            };
+        }
+        try {
+            await (0, invoke_webhook_1.invokeWebhook)({
+                url: params.webhook.url,
+                secret: params.webhook.secret,
+                payload: {
+                    type: 'success',
                     renderId: params.renderId,
                     expectedBucketOwner: options.expectedBucketOwner,
-                });
-                renderer_1.RenderInternals.Log.error('Failed to invoke webhook:');
-                renderer_1.RenderInternals.Log.error(err);
+                    bucketName: params.bucketName,
+                    customData: (_b = params.webhook.customData) !== null && _b !== void 0 ? _b : null,
+                    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',
@@ -586,7 +479,7 @@ const launchHandler = async (params, options) => {
                         renderId: params.renderId,
                         expectedBucketOwner: options.expectedBucketOwner,
                         bucketName: params.bucketName,
-                        customData: (_b = params.webhook.customData) !== null && _b !== void 0 ? _b : null,
+                        customData: (_c = params.webhook.customData) !== null && _c !== void 0 ? _c : null,
                         errors: [err].map((e) => ({
                             message: e.message,
                             name: e.name,

package/dist/functions/merge.d.ts

@@ -0,0 +1,9 @@
+import type { LambdaPayload, PostRenderData } from '../defaults';
+type Options = {
+    expectedBucketOwner: string;
+};
+export declare const mergeHandler: (params: LambdaPayload, options: Options) => Promise<{
+    type: 'success';
+    postRenderData: PostRenderData;
+}>;
+export {};

package/dist/functions/merge.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const defaults_1 = require("../defaults");
+const expected_out_name_1 = require("./helpers/expected-out-name");
+const get_current_region_1 = require("./helpers/get-current-region");
+const get_render_metadata_1 = require("./helpers/get-render-metadata");
+const merge_chunks_1 = require("./helpers/merge-chunks");
+const mergeHandler = async (params, options) => {
+    var _a, _b;
+    if (params.type !== defaults_1.LambdaRoutines.merge) {
+        throw new Error('Expected launch type');
+    }
+    renderer_1.RenderInternals.Log.info('This function has been started because the previous main function has timed out while merging together the chunks.');
+    renderer_1.RenderInternals.Log.info('The merging of chunks will now restart.');
+    const renderMetadata = await (0, get_render_metadata_1.getRenderMetadata)({
+        bucketName: params.bucketName,
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        renderId: params.renderId,
+    });
+    if (!renderMetadata.codec) {
+        throw new Error('expected codec');
+    }
+    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
+        ? null
+        : (_b = (_a = params.outName) === null || _a === void 0 ? void 0 : _a.s3OutputProvider) !== null && _b !== void 0 ? _b : null);
+    const frameCount = renderer_1.RenderInternals.getFramesToRender(renderMetadata.frameRange, renderMetadata.everyNthFrame);
+    const fps = renderMetadata.videoConfig.fps / renderMetadata.everyNthFrame;
+    const postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
+        audioCodec: renderMetadata.audioCodec,
+        bucketName: params.bucketName,
+        chunkCount: renderMetadata.totalChunks,
+        codec: renderMetadata.codec,
+        customCredentials,
+        downloadBehavior: renderMetadata.downloadBehavior,
+        expectedBucketOwner: options.expectedBucketOwner,
+        fps,
+        frameCountLength: frameCount.length,
+        inputProps: params.inputProps,
+        key,
+        numberOfGifLoops: renderMetadata.numberOfGifLoops,
+        privacy: renderMetadata.privacy,
+        renderBucketName,
+        renderId: params.renderId,
+        renderMetadata,
+        serializedResolvedProps: params.serializedResolvedProps,
+        verbose: params.verbose,
+        onAllChunks: () => {
+            renderer_1.RenderInternals.Log.info('All chunks have been downloaded now.');
+        },
+    });
+    return { type: 'success', postRenderData };
+};
+exports.mergeHandler = mergeHandler;

package/dist/functions/still.js

@@ -115,6 +115,8 @@ const innerStillHandler = async ({ params: lambdaParams, expectedBucketOwner, re
         frameRange: [lambdaParams.frame, lambdaParams.frame],
         audioCodec: null,
         deleteAfter: lambdaParams.deleteAfter,
+        numberOfGifLoops: null,
+        downloadBehavior: lambdaParams.downloadBehavior,
     };
     await (0, io_1.lambdaWriteFile)({
         bucketName,

package/dist/shared/constants.d.ts

@@ -1,4 +1,4 @@
-import type { AudioCodec, ChromiumOptions, Codec, ColorSpace, FrameRange, LogLevel, PixelFormat, ProResProfile, StillImageFormat, ToOptions, VideoImageFormat, X264Preset } from '@remotion/renderer';
+import type { AudioCodec, ChromiumOptions, ColorSpace, FrameRange, LogLevel, PixelFormat, ProResProfile, StillImageFormat, ToOptions, VideoImageFormat, X264Preset } from '@remotion/renderer';
 import type { BrowserSafeApis } from '@remotion/renderer/client';
 import type { VideoConfig } from 'remotion';
 import type { ChunkRetry } from '../functions/helpers/get-retry-stats';
@@ -95,7 +95,8 @@ export declare enum LambdaRoutines {
     status = "status",
     renderer = "renderer",
     still = "still",
-    compositions = "compositions"
+    compositions = "compositions",
+    merge = "merge"
 }
 type Prettify<T> = {
     [K in keyof T]: T[K];
@@ -264,7 +265,7 @@ export type LambdaPayloads = {
         timeoutInMilliseconds: number;
         chromiumOptions: ChromiumOptions;
         scale: number;
-        downloadBehavior: DownloadBehavior | null;
+        downloadBehavior: DownloadBehavior;
         version: string;
         forceHeight: number | null;
         forceWidth: number | null;
@@ -284,6 +285,16 @@ export type LambdaPayloads = {
         bucketName: string | null;
         offthreadVideoCacheSizeInBytes: number | null;
     };
+    merge: {
+        type: LambdaRoutines.merge;
+        bucketName: string;
+        renderId: string;
+        outName: OutNameInput | null;
+        inputProps: SerializedInputProps;
+        serializedResolvedProps: SerializedInputProps;
+        verbose: boolean;
+        logLevel: LogLevel;
+    };
 };
 export type LambdaPayload = LambdaPayloads[LambdaRoutines];
 export type EncodingProgress = {
@@ -304,7 +315,7 @@ export type RenderMetadata = Discriminated & {
     estimatedTotalLambdaInvokations: number;
     estimatedRenderLambdaInvokations: number;
     compositionId: string;
-    codec: Codec | null;
+    codec: LambdaCodec | null;
     audioCodec: AudioCodec | null;
     inputProps: SerializedInputProps;
     framesPerLambda: number;
@@ -317,6 +328,8 @@ export type RenderMetadata = Discriminated & {
     frameRange: [number, number];
     everyNthFrame: number;
     deleteAfter: DeleteAfter | null;
+    numberOfGifLoops: number | null;
+    downloadBehavior: DownloadBehavior;
 };
 export type AfterRenderCost = {
     estimatedCost: number;

package/dist/shared/constants.js

@@ -103,6 +103,7 @@ var LambdaRoutines;
     LambdaRoutines["renderer"] = "renderer";
     LambdaRoutines["still"] = "still";
     LambdaRoutines["compositions"] = "compositions";
+    LambdaRoutines["merge"] = "merge";
 })(LambdaRoutines = exports.LambdaRoutines || (exports.LambdaRoutines = {}));
 exports.LAMBDA_CONCURRENCY_LIMIT_QUOTA = 'L-B99A9384';
 exports.LAMBDA_BURST_LIMIT_QUOTA = 'L-548AE339';

package/dist/shared/return-values.d.ts

@@ -1,6 +1,7 @@
 import type { compositionsHandler } from '../functions/compositions';
 import type { infoHandler } from '../functions/info';
 import type { launchHandler } from '../functions/launch';
+import type { mergeHandler } from '../functions/merge';
 import type { progressHandler } from '../functions/progress';
 import type { rendererHandler } from '../functions/renderer';
 import type { startHandler } from '../functions/start';
@@ -19,4 +20,5 @@ export interface LambdaReturnValues {
     [LambdaRoutines.info]: ReturnType<typeof infoHandler>;
     [LambdaRoutines.still]: ReturnType<typeof stillHandler>;
     [LambdaRoutines.compositions]: ReturnType<typeof compositionsHandler>;
+    [LambdaRoutines.merge]: ReturnType<typeof mergeHandler>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/lambda",
-  "version": "4.0.43",
+  "version": "4.0.45",
   "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.43",
-    "remotion": "4.0.43",
-    "@remotion/renderer": "4.0.43",
-    "@remotion/cli": "4.0.43"
+    "@remotion/cli": "4.0.45",
+    "@remotion/bundler": "4.0.45",
+    "@remotion/renderer": "4.0.45",
+    "remotion": "4.0.45"
   },
   "devDependencies": {
     "@jonny/eslint-config": "3.0.266",
@@ -43,11 +43,11 @@
     "ts-node": "^10.8.0",
     "vitest": "0.31.1",
     "zip-lib": "^0.7.2",
-    "@remotion/bundler": "4.0.43",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.43"
+    "@remotion/bundler": "4.0.45",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.45"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.43"
+    "@remotion/bundler": "4.0.45"
   },
   "publishConfig": {
     "access": "public"