@remotion/lambda 4.0.0-webhook.27 → 4.1.0-alpha3

package/dist/functions/launch.js

@@ -1,30 +1,46 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 fs_1 = __importDefault(require("fs"));
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = require("node:path");
 const remotion_1 = require("remotion");
 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 constants_1 = require("../shared/constants");
+const deserialize_input_props_1 = require("../shared/deserialize-input-props");
 const docs_url_1 = require("../shared/docs-url");
 const invoke_webhook_1 = require("../shared/invoke-webhook");
 const make_s3_url_1 = require("../shared/make-s3-url");
 const validate_frames_per_lambda_1 = require("../shared/validate-frames-per-lambda");
 const validate_outname_1 = require("../shared/validate-outname");
 const validate_privacy_1 = require("../shared/validate-privacy");
-const collect_data_1 = require("./chunk-optimization/collect-data");
-const get_frame_ranges_from_profile_1 = require("./chunk-optimization/get-frame-ranges-from-profile");
-const get_profile_duration_1 = require("./chunk-optimization/get-profile-duration");
-const is_valid_profile_1 = require("./chunk-optimization/is-valid-profile");
-const optimize_invocation_order_1 = require("./chunk-optimization/optimize-invocation-order");
-const optimize_profile_1 = require("./chunk-optimization/optimize-profile");
 const plan_frame_ranges_1 = require("./chunk-optimization/plan-frame-ranges");
-const s3_optimization_file_1 = require("./chunk-optimization/s3-optimization-file");
 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");
@@ -34,7 +50,6 @@ const find_output_file_in_bucket_1 = require("./helpers/find-output-file-in-buck
 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_lambdas_invoked_stats_1 = require("./helpers/get-lambdas-invoked-stats");
 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");
@@ -42,10 +57,10 @@ 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 = 0) => {
+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({
-            FunctionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+            FunctionName: functionName,
             // @ts-expect-error
             Payload: JSON.stringify(payload),
             InvocationType: 'Event',
@@ -59,17 +74,25 @@ const callFunctionWithRetry = async (payload, retries = 0) => {
             await new Promise((resolve) => {
                 setTimeout(resolve, 1000);
             });
-            return callFunctionWithRetry(payload, retries + 1);
+            return callFunctionWithRetry({
+                payload,
+                retries: retries + 1,
+                functionName,
+            });
         }
+        throw err;
     }
 };
 const innerLaunchHandler = async (params, options) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     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();
     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 {
@@ -111,60 +134,59 @@ const innerLaunchHandler = async (params, options) => {
                 console.log(err);
             }
         }
-    }, Math.max(params.timeoutInMilliseconds - 1000, 1000));
-    const [browserInstance, optimization] = await Promise.all([
-        (0, get_browser_instance_1.getBrowserInstance)(renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose'), params.chromiumOptions),
-        (0, s3_optimization_file_1.getOptimization)({
-            bucketName: params.bucketName,
-            siteId: (0, make_s3_url_1.getServeUrlHash)(params.serveUrl),
-            compositionId: params.composition,
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            expectedBucketOwner: options.expectedBucketOwner,
-        }),
-    ]);
-    const downloadMap = renderer_1.RenderInternals.makeDownloadMap();
+    }, Math.max(options.getRemainingTimeInMillis() - 1000, 1000));
+    const browserInstance = await (0, get_browser_instance_1.getBrowserInstance)(params.logLevel, false, params.chromiumOptions);
+    const inputPropsPromise = (0, deserialize_input_props_1.deserializeInputProps)({
+        bucketName: params.bucketName,
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        serialized: params.inputProps,
+    });
     const comp = await (0, validate_composition_1.validateComposition)({
         serveUrl: params.serveUrl,
         composition: params.composition,
         browserInstance,
-        inputProps: params.inputProps,
-        envVariables: params.envVariables,
-        ffmpegExecutable: null,
-        ffprobeExecutable: null,
+        inputProps: await inputPropsPromise,
+        envVariables: (_b = params.envVariables) !== null && _b !== void 0 ? _b : {},
         timeoutInMilliseconds: params.timeoutInMilliseconds,
         chromiumOptions: params.chromiumOptions,
         port: null,
-        downloadMap,
+        forceHeight: params.forceHeight,
+        forceWidth: params.forceWidth,
+        logLevel: params.logLevel,
+        server: undefined,
+    });
+    remotion_1.Internals.validateDurationInFrames({
+        durationInFrames: comp.durationInFrames,
+        component: 'passed to a Lambda render',
+        allowFloats: false,
     });
-    remotion_1.Internals.validateDurationInFrames(comp.durationInFrames, 'passed to a Lambda render');
     remotion_1.Internals.validateFps(comp.fps, 'passed to a Lambda render', false);
     remotion_1.Internals.validateDimension(comp.height, 'height', 'passed to a Lambda render');
     remotion_1.Internals.validateDimension(comp.width, 'width', 'passed to a Lambda render');
+    renderer_1.RenderInternals.validateBitrate(params.audioBitrate, 'audioBitrate');
+    renderer_1.RenderInternals.validateBitrate(params.videoBitrate, 'videoBitrate');
     renderer_1.RenderInternals.validateConcurrency(params.concurrencyPerLambda, 'concurrencyPerLambda');
     const realFrameRange = renderer_1.RenderInternals.getRealFrameRange(comp.durationInFrames, params.frameRange);
     const frameCount = renderer_1.RenderInternals.getFramesToRender(realFrameRange, params.everyNthFrame);
-    const framesPerLambda = (_a = params.framesPerLambda) !== null && _a !== void 0 ? _a : (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(frameCount.length);
+    const framesPerLambda = (_c = params.framesPerLambda) !== null && _c !== void 0 ? _c : (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 for how this parameter is calculated.`);
+        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);
-    (0, validate_privacy_1.validatePrivacy)(params.privacy);
+    (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);
-    const { chunks, didUseOptimization } = (0, plan_frame_ranges_1.planFrameRanges)({
+    const { chunks } = (0, plan_frame_ranges_1.planFrameRanges)({
         framesPerLambda,
-        optimization,
-        // TODO: Re-enable chunk optimization later
-        shouldUseOptimization: false,
         frameRange: realFrameRange,
         everyNthFrame: params.everyNthFrame,
     });
     const sortedChunks = chunks.slice().sort((a, b) => a[0] - b[0]);
-    const invokers = Math.round(Math.sqrt(chunks.length));
     const reqSend = (0, timer_1.timer)('sending off requests');
     const lambdaPayloads = chunks.map((chunkPayload) => {
         var _a;
@@ -183,12 +205,12 @@ const innerLaunchHandler = async (params, options) => {
             inputProps: params.inputProps,
             renderId: params.renderId,
             imageFormat: params.imageFormat,
-            codec: params.codec === 'h264' ? 'h264-mkv' : params.codec,
+            codec: params.codec,
             crf: params.crf,
             envVariables: params.envVariables,
             pixelFormat: params.pixelFormat,
             proResProfile: params.proResProfile,
-            quality: params.quality,
+            jpegQuality: params.jpegQuality,
             privacy: params.privacy,
             logLevel: (_a = params.logLevel) !== null && _a !== void 0 ? _a : 'info',
             attempt: 1,
@@ -198,9 +220,15 @@ const innerLaunchHandler = async (params, options) => {
             everyNthFrame: params.everyNthFrame,
             concurrencyPerLambda: params.concurrencyPerLambda,
             muted: params.muted,
+            audioBitrate: params.audioBitrate,
+            videoBitrate: params.videoBitrate,
+            launchFunctionConfig: {
+                version: version_1.VERSION,
+            },
         };
         return payload;
     });
+    console.log('Render plan: ', chunks.map((c, i) => `Chunk ${i} (Frames ${c[0]} - ${c[1]})`).join(', '));
     const renderMetadata = {
         startedDate,
         videoConfig: comp,
@@ -208,15 +236,13 @@ const innerLaunchHandler = async (params, options) => {
         estimatedTotalLambdaInvokations: [
             // Direct invokations
             chunks.length,
-            // Parent invokers
-            invokers,
             // This function
+            1,
         ].reduce((a, b) => a + b, 0),
         estimatedRenderLambdaInvokations: chunks.length,
         compositionId: comp.id,
         siteId: (0, make_s3_url_1.getServeUrlHash)(params.serveUrl),
         codec: params.codec,
-        usesOptimizationProfile: didUseOptimization,
         type: 'video',
         imageFormat: params.imageFormat,
         inputProps: params.inputProps,
@@ -225,12 +251,15 @@ 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: (_b = params.outName) !== null && _b !== void 0 ? _b : undefined,
+        outName: (_d = params.outName) !== null && _d !== void 0 ? _d : undefined,
         privacy: params.privacy,
+        everyNthFrame: params.everyNthFrame,
+        frameRange: realFrameRange,
+        audioCodec: params.audioCodec,
     };
     const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
         ? null
-        : (_d = (_c = params.outName) === null || _c === void 0 ? void 0 : _c.s3OutputProvider) !== null && _d !== void 0 ? _d : null);
+        : (_f = (_e = params.outName) === null || _e === void 0 ? void 0 : _e.s3OutputProvider) !== null && _f !== void 0 ? _f : null);
     const output = await (0, find_output_file_in_bucket_1.findOutputFileInBucket)({
         bucketName: params.bucketName,
         customCredentials,
@@ -261,34 +290,22 @@ const innerLaunchHandler = async (params, options) => {
         downloadBehavior: null,
         customCredentials: null,
     });
-    await Promise.all(lambdaPayloads.map(async (payload, index) => {
-        const callingLambdaTimer = (0, timer_1.timer)('Calling chunk ' + index);
-        await callFunctionWithRetry(payload);
-        callingLambdaTimer.end();
+    await Promise.all(lambdaPayloads.map(async (payload) => {
+        await callFunctionWithRetry({ payload, retries: 0, functionName });
     }));
     reqSend.end();
     let lastProgressUploaded = 0;
-    let encodingStop = null;
-    const onProgress = (framesEncoded, start) => {
+    const onProgress = (framesEncoded) => {
         const relativeProgress = framesEncoded / frameCount.length;
         const deltaSinceLastProgressUploaded = relativeProgress - lastProgressUploaded;
-        if (relativeProgress === 1) {
-            encodingStop = Date.now();
-        }
         if (deltaSinceLastProgressUploaded < 0.1) {
             return;
         }
         lastProgressUploaded = relativeProgress;
-        const encodingProgress = {
-            framesEncoded,
-            totalFrames: frameCount.length,
-            doneIn: encodingStop ? encodingStop - start : null,
-            timeToInvoke: null,
-        };
         (0, io_1.lambdaWriteFile)({
             bucketName: params.bucketName,
             key: (0, constants_1.encodingProgressKey)(params.renderId),
-            body: JSON.stringify(encodingProgress),
+            body: String(Math.round(framesEncoded / constants_1.ENCODING_PROGRESS_STEP_SIZE)),
             region: (0, get_current_region_1.getCurrentRegionInFunction)(),
             privacy: 'private',
             expectedBucketOwner: options.expectedBucketOwner,
@@ -315,90 +332,82 @@ 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');
+        }
+        throw new Error('Stopping Lambda function because error occurred: ' + errors[0].stack);
+    };
     const fps = comp.fps / params.everyNthFrame;
-    const { outfile, cleanupChunksProm, encodingStart } = await (0, concat_videos_1.concatVideosS3)({
+    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,
-        onProgress,
-        numberOfFrames: frameCount.length,
+        outdir,
         renderId: params.renderId,
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        codec: params.codec,
         expectedBucketOwner: options.expectedBucketOwner,
+        onErrors,
+    });
+    const encodingStart = Date.now();
+    const { outfile, cleanupChunksProm } = await (0, concat_videos_1.concatVideosS3)({
+        onProgress,
+        numberOfFrames: frameCount.length,
+        codec: params.codec,
         fps,
         numberOfGifLoops: params.numberOfGifLoops,
+        files,
+        outdir,
+        audioCodec: params.audioCodec,
     });
-    if (!encodingStop) {
-        encodingStop = Date.now();
-    }
-    const outputSize = fs_1.default.statSync(outfile);
+    const encodingStop = Date.now();
+    const outputSize = node_fs_1.default.statSync(outfile);
     await (0, io_1.lambdaWriteFile)({
         bucketName: renderBucketName,
         key,
-        body: fs_1.default.createReadStream(outfile),
+        body: node_fs_1.default.createReadStream(outfile),
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         privacy: params.privacy,
         expectedBucketOwner: options.expectedBucketOwner,
         downloadBehavior: params.downloadBehavior,
         customCredentials,
     });
-    let chunkProm = Promise.resolve();
-    // TODO: Enable in a later release
-    const enableChunkOptimization = false;
-    if (enableChunkOptimization) {
-        const chunkData = await (0, collect_data_1.collectChunkInformation)({
-            bucketName: params.bucketName,
-            renderId: params.renderId,
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            expectedBucketOwner: options.expectedBucketOwner,
-        });
-        const optimizedProfile = (0, optimize_invocation_order_1.optimizeInvocationOrder)((0, optimize_profile_1.optimizeProfileRecursively)(chunkData, 400));
-        const optimizedFrameRange = (0, get_frame_ranges_from_profile_1.getFrameRangesFromProfile)(optimizedProfile);
-        chunkProm = (0, is_valid_profile_1.isValidOptimizationProfile)(optimizedProfile)
-            ? (0, s3_optimization_file_1.writeOptimization)({
-                bucketName: params.bucketName,
-                optimization: {
-                    ranges: optimizedFrameRange,
-                    oldTiming: (0, get_profile_duration_1.getProfileDuration)(chunkData),
-                    newTiming: (0, get_profile_duration_1.getProfileDuration)(optimizedProfile),
-                    createdFromRenderId: params.renderId,
-                    framesPerLambda,
-                    lambdaVersion: version_1.VERSION,
-                    frameRange: realFrameRange,
-                    everyNthFrame: params.everyNthFrame,
-                },
-                expectedBucketOwner: options.expectedBucketOwner,
-                compositionId: params.composition,
-                siteId: (0, make_s3_url_1.getServeUrlHash)(params.serveUrl),
-                region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            })
-            : Promise.resolve();
-    }
-    const [, contents] = await Promise.all([
-        chunkProm,
-        (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 finalEncodingProgress = {
-        framesEncoded: frameCount.length,
-        totalFrames: frameCount.length,
-        doneIn: encodingStop ? encodingStop - encodingStart : null,
-        timeToInvoke: (0, get_lambdas_invoked_stats_1.getLambdasInvokedStats)({
-            contents,
-            renderId: params.renderId,
-            estimatedRenderLambdaInvokations: renderMetadata.estimatedRenderLambdaInvokations,
-            checkIfAllLambdasWereInvoked: false,
-            startDate: renderMetadata.startedDate,
-        }).timeToInvokeLambdas,
-    };
+    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: JSON.stringify(finalEncodingProgress),
+        body: String(Math.ceil(frameCount.length / constants_1.ENCODING_PROGRESS_STEP_SIZE)),
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         privacy: 'private',
         expectedBucketOwner: options.expectedBucketOwner,
@@ -416,11 +425,18 @@ const innerLaunchHandler = async (params, options) => {
         chunkCount,
         renderId: params.renderId,
     });
-    const deletProm = (0, delete_chunks_1.cleanupFiles)({
+    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)(),
-        bucket: params.bucketName,
-        contents,
-        jobs,
+        serialized: params.inputProps,
     });
     const outputUrl = (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(renderMetadata, params.bucketName, customCredentials);
     const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
@@ -432,7 +448,7 @@ const innerLaunchHandler = async (params, options) => {
         contents,
         errorExplanations: await errorExplanationsProm,
         timeToEncode: encodingStop - encodingStart,
-        timeToDelete: await deletProm,
+        timeToDelete: (await Promise.all([deletProm, cleanupSerializedInputPropsProm])).reduce((a, b) => a + b, 0),
         outputFile: {
             lastModified: Date.now(),
             size: outputSize.size,
@@ -453,7 +469,7 @@ const innerLaunchHandler = async (params, options) => {
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         customCredentials: null,
     });
-    await Promise.all([cleanupChunksProm, fs_1.default.promises.rm(outfile)]);
+    await Promise.all([cleanupChunksProm, node_fs_1.default.promises.rm(outfile)]);
     clearTimeout(webhookDueToTimeout);
     if (params.webhook && !webhookInvoked) {
         try {
@@ -469,6 +485,7 @@ const innerLaunchHandler = async (params, options) => {
                     lambdaErrors: postRenderData.errors,
                     outputFile: postRenderData.outputFile,
                     timeToFinish: postRenderData.timeToFinish,
+                    costs: postRenderData.cost,
                 },
             });
             webhookInvoked = true;

package/dist/functions/progress.d.ts

@@ -1,5 +1,5 @@
 import type { LambdaPayload, RenderProgress } from '../shared/constants';
-declare type Options = {
+type Options = {
     expectedBucketOwner: string;
     timeoutInMilliseconds: number;
 };

package/dist/functions/progress.js

@@ -12,9 +12,9 @@ const progressHandler = (lambdaParams, options) => {
     }
     if (lambdaParams.version !== version_1.VERSION) {
         if (!lambdaParams.version) {
-            throw new Error(`Version mismatch: When calling getRenderProgress(), the deployed Lambda function had version ${version_1.VERSION} but the @remotion/lambda package is an older version. Align the versions.`);
+            throw new Error(`Version mismatch: When calling getRenderProgress(), you called the function ${process.env.AWS_LAMBDA_FUNCTION_NAME} which has the version ${version_1.VERSION} but the @remotion/lambda package is an older version. Deploy a new function and use it to call getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
         }
-        throw new Error(`Version mismatch: When calling getRenderProgress(), get deployed Lambda function had version ${version_1.VERSION} and the @remotion/lambda package has version ${lambdaParams.version}. Align the versions.`);
+        throw new Error(`Version mismatch: When calling getRenderProgress(), you passed ${process.env.AWS_LAMBDA_FUNCTION_NAME} as the function, which has the version ${version_1.VERSION}, but the @remotion/lambda package you used to invoke the function has version ${lambdaParams.version}. Deploy a new function and use it to call getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
     }
     return (0, get_progress_1.getProgress)({
         bucketName: lambdaParams.bucketName,

package/dist/functions/renderer.d.ts

@@ -1,5 +1,5 @@
 import type { LambdaPayload } from '../shared/constants';
-declare type Options = {
+type Options = {
     expectedBucketOwner: string;
     isWarm: boolean;
 };