@remotion/lambda 4.0.0-lambda.3 → 4.0.0-newpaths.13

package/dist/functions/launch.js

@@ -1,37 +1,55 @@
 "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 fs_1 = __importStar(require("fs"));
+const path_1 = require("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");
 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_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");
@@ -39,56 +57,131 @@ 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({
+            FunctionName: functionName,
+            // @ts-expect-error
+            Payload: JSON.stringify(payload),
+            InvocationType: 'Event',
+        }), {});
+    }
+    catch (err) {
+        if (err.name === 'ResourceConflictException') {
+            if (retries > 10) {
+                throw err;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, 1000);
+            });
+            return callFunctionWithRetry({
+                payload,
+                retries: retries + 1,
+                functionName,
+            });
+        }
+    }
+};
 const innerLaunchHandler = async (params, options) => {
-    var _a, _b;
+    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 [browserInstance, optimization] = await Promise.all([
-        (0, get_browser_instance_1.getBrowserInstance)(remotion_1.Internals.Logging.isEqualOrBelowLogLevel(remotion_1.Internals.Logging.getLogLevel(), '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,
-        }),
-    ]);
+    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)(verbose, params.chromiumOptions);
+    const downloadMap = renderer_1.RenderInternals.makeDownloadMap();
+    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,
+        inputProps: await inputPropsPromise,
         envVariables: params.envVariables,
         ffmpegExecutable: null,
         ffprobeExecutable: null,
         timeoutInMilliseconds: params.timeoutInMilliseconds,
         chromiumOptions: params.chromiumOptions,
         port: null,
+        downloadMap,
+        forceHeight: params.forceHeight,
+        forceWidth: params.forceWidth,
     });
-    remotion_1.Internals.validateDurationInFrames(comp.durationInFrames, 'passed to <Component />');
-    remotion_1.Internals.validateFps(comp.fps, 'passed to <Component />');
-    remotion_1.Internals.validateDimension(comp.height, 'height', 'passed to <Component />');
-    remotion_1.Internals.validateDimension(comp.width, 'width', 'passed to <Component />');
+    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.getDurationFromFrameRange(realFrameRange, 0);
-    const framesPerLambda = (_a = params.framesPerLambda) !== null && _a !== void 0 ? _a : (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(frameCount);
-    (0, validate_frames_per_lambda_1.validateFramesPerLambda)(framesPerLambda);
-    const chunkCount = Math.ceil(frameCount / framesPerLambda);
+    const frameCount = renderer_1.RenderInternals.getFramesToRender(realFrameRange, params.everyNthFrame);
+    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 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);
+    (0, validate_outname_1.validateOutname)(params.outName, params.codec);
     (0, validate_privacy_1.validatePrivacy)(params.privacy);
     renderer_1.RenderInternals.validatePuppeteerTimeout(params.timeoutInMilliseconds);
-    const { chunks, didUseOptimization } = (0, plan_frame_ranges_1.planFrameRanges)({
-        chunkCount,
+    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));
@@ -117,11 +210,19 @@ const innerLaunchHandler = async (params, options) => {
             proResProfile: params.proResProfile,
             quality: params.quality,
             privacy: params.privacy,
-            logLevel: (_a = params.logLevel) !== null && _a !== void 0 ? _a : remotion_1.Internals.Logging.DEFAULT_LOG_LEVEL,
+            logLevel: (_a = params.logLevel) !== null && _a !== void 0 ? _a : 'info',
             attempt: 1,
             timeoutInMilliseconds: params.timeoutInMilliseconds,
             chromiumOptions: params.chromiumOptions,
             scale: params.scale,
+            everyNthFrame: params.everyNthFrame,
+            concurrencyPerLambda: params.concurrencyPerLambda,
+            muted: params.muted,
+            audioBitrate: params.audioBitrate,
+            videoBitrate: params.videoBitrate,
+            launchFunctionConfig: {
+                version: version_1.VERSION,
+            },
         };
         return payload;
     });
@@ -140,17 +241,42 @@ const innerLaunchHandler = async (params, options) => {
         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,
-        lambdaVersion: constants_1.CURRENT_VERSION,
+        lambdaVersion: version_1.VERSION,
         framesPerLambda,
         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: (_c = params.outName) !== null && _c !== void 0 ? _c : undefined,
+        privacy: params.privacy,
+        everyNthFrame: params.everyNthFrame,
+        frameRange: realFrameRange,
     };
+    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
+        ? 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,
+        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        renderMetadata,
+    });
+    if (output) {
+        if (params.overwrite) {
+            console.info('Deleting', { bucketName: renderBucketName, key }, 'because it already existed and will be overwritten');
+            await (0, io_1.lambdaDeleteFile)({
+                bucketName: renderBucketName,
+                customCredentials,
+                key,
+                region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            });
+        }
+        else {
+            throw new TypeError(`Output file "${key}" in bucket "${renderBucketName}" in region "${(0, get_current_region_1.getCurrentRegionInFunction)()}" already exists. Delete it before re-rendering, or use the overwrite option to delete it before render."`);
+        }
+    }
     await (0, io_1.lambdaWriteFile)({
         bucketName: params.bucketName,
         key: (0, constants_1.renderMetadataKey)(params.renderId),
@@ -158,43 +284,32 @@ const innerLaunchHandler = async (params, options) => {
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         privacy: 'private',
         expectedBucketOwner: options.expectedBucketOwner,
+        downloadBehavior: null,
+        customCredentials: null,
     });
     await Promise.all(lambdaPayloads.map(async (payload, index) => {
         const callingLambdaTimer = (0, timer_1.timer)('Calling chunk ' + index);
-        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,
-            // @ts-expect-error
-            Payload: JSON.stringify(payload),
-            InvocationType: 'Event',
-        }), {});
+        await callFunctionWithRetry({ payload, retries: 0, functionName });
         callingLambdaTimer.end();
     }));
     reqSend.end();
     let lastProgressUploaded = 0;
-    let encodingStop = null;
-    const onProgress = (framesEncoded, start) => {
-        const relativeProgress = framesEncoded / frameCount;
+    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,
-            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(framesEncoded),
             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,
@@ -216,21 +331,62 @@ const innerLaunchHandler = async (params, options) => {
             });
         });
     };
-    const { outfile, cleanupChunksProm, encodingStart } = await (0, concat_videos_1.concatVideosS3)({
+    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 outdir = (0, path_1.join)(renderer_1.RenderInternals.tmpDir(constants_1.CONCAT_FOLDER_TOKEN), 'bucket');
+    if ((0, fs_1.existsSync)(outdir)) {
+        (fs_1.rmSync !== null && fs_1.rmSync !== void 0 ? fs_1.rmSync : fs_1.rmdirSync)(outdir, {
+            recursive: true,
+        });
+    }
+    (0, fs_1.mkdirSync)(outdir);
+    const files = await (0, concat_videos_1.getAllFilesS3)({
         bucket: params.bucketName,
         expectedFiles: chunkCount,
-        onProgress,
-        numberOfFrames: frameCount,
+        outdir,
         renderId: params.renderId,
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        codec: params.codec,
         expectedBucketOwner: options.expectedBucketOwner,
-        fps: comp.fps,
+        onErrors,
     });
-    if (!encodingStop) {
-        encodingStop = Date.now();
-    }
-    const { key, renderBucketName } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName);
+    const encodingStart = Date.now();
+    const { outfile, cleanupChunksProm } = await (0, concat_videos_1.concatVideosS3)({
+        onProgress,
+        numberOfFrames: frameCount.length,
+        codec: params.codec,
+        fps,
+        numberOfGifLoops: params.numberOfGifLoops,
+        ffmpegExecutable: null,
+        remotionRoot: process.cwd(),
+        files,
+        outdir,
+    });
+    const encodingStop = Date.now();
     const outputSize = fs_1.default.statSync(outfile);
     await (0, io_1.lambdaWriteFile)({
         bucketName: renderBucketName,
@@ -239,60 +395,24 @@ const innerLaunchHandler = async (params, options) => {
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         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)(),
     });
-    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: constants_1.CURRENT_VERSION,
-                    frameRange: realFrameRange,
-                },
-                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,
-        totalFrames: frameCount,
-        doneIn: encodingStop ? encodingStop - encodingStart : null,
-        timeToInvoke: (0, get_lambdas_invoked_stats_1.getLambdasInvokedStats)(contents, params.renderId, renderMetadata.estimatedRenderLambdaInvokations, renderMetadata.startedDate).timeToInvokeLambdas,
-    };
     const finalEncodingProgressProm = (0, io_1.lambdaWriteFile)({
         bucketName: params.bucketName,
         key: (0, constants_1.encodingProgressKey)(params.renderId),
-        body: JSON.stringify(finalEncodingProgress),
+        body: String(frameCount.length),
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         privacy: 'private',
         expectedBucketOwner: options.expectedBucketOwner,
+        downloadBehavior: null,
+        customCredentials: null,
     });
     const errorExplanationsProm = (0, inspect_errors_1.inspectErrors)({
         contents,
@@ -305,13 +425,21 @@ 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 postRenderData = await (0, create_post_render_data_1.createPostRenderData)({
+    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,
@@ -320,11 +448,11 @@ 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,
-            url: (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(renderMetadata, params.bucketName),
+            url: outputUrl,
         },
     });
     await finalEncodingProgressProm;
@@ -335,9 +463,62 @@ const innerLaunchHandler = async (params, options) => {
         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, 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);
+        }
+    }
 };
 const launchHandler = async (params, options) => {
+    var _a, _b;
     if (params.type !== constants_1.LambdaRoutines.launch) {
         throw new Error('Expected launch type');
     }
@@ -345,6 +526,9 @@ const launchHandler = async (params, options) => {
         await innerLaunchHandler(params, options);
     }
     catch (err) {
+        if (process.env.NODE_ENV === 'test') {
+            throw err;
+        }
         console.log('Error occurred', err);
         await (0, write_lambda_error_1.writeLambdaError)({
             bucketName: params.bucketName,
@@ -364,6 +548,50 @@ const launchHandler = async (params, options) => {
             expectedBucketOwner: options.expectedBucketOwner,
             renderId: params.renderId,
         });
+        if ((_a = params.webhook) === null || _a === void 0 ? void 0 : _a.url) {
+            try {
+                await (0, invoke_webhook_1.invokeWebhook)({
+                    url: params.webhook.url,
+                    secret: (_b = params.webhook.secret) !== null && _b !== void 0 ? _b : null,
+                    payload: {
+                        type: 'error',
+                        renderId: params.renderId,
+                        expectedBucketOwner: options.expectedBucketOwner,
+                        bucketName: params.bucketName,
+                        errors: [err].map((e) => ({
+                            message: e.message,
+                            name: e.name,
+                            stack: e.stack,
+                        })),
+                    },
+                });
+            }
+            catch (error) {
+                if (process.env.NODE_ENV === 'test') {
+                    throw error;
+                }
+                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(error);
+            }
+        }
     }
 };
 exports.launchHandler = launchHandler;

package/dist/functions/progress.d.ts

@@ -1,7 +1,7 @@
-import { LambdaPayload, RenderProgress } from '../shared/constants';
+import type { LambdaPayload, RenderProgress } from '../shared/constants';
 declare type Options = {
     expectedBucketOwner: string;
-    timeoutInMiliseconds: number;
+    timeoutInMilliseconds: number;
 };
 export declare const progressHandler: (lambdaParams: LambdaPayload, options: Options) => Promise<RenderProgress>;
 export {};