@remotion/lambda 4.0.0-umungobongo.5 → 4.0.0-webhook.26

package/dist/functions/launch.js

@@ -8,9 +8,11 @@ const client_lambda_1 = require("@aws-sdk/client-lambda");
 const renderer_1 = require("@remotion/renderer");
 const fs_1 = __importDefault(require("fs"));
 const remotion_1 = require("remotion");
+const version_1 = require("remotion/version");
 const aws_clients_1 = require("../shared/aws-clients");
 const constants_1 = require("../shared/constants");
 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");
@@ -28,6 +30,7 @@ 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");
@@ -39,12 +42,76 @@ 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) => {
+    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,
+            // @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 + 1);
+        }
+    }
+};
 const innerLaunchHandler = async (params, options) => {
-    var _a, _b;
+    var _a, _b, _c, _d;
     if (params.type !== constants_1.LambdaRoutines.launch) {
         throw new Error('Expected launch type');
     }
     const startedDate = Date.now();
+    let webhookInvoked = false;
+    const webhookDueToTimeout = setTimeout(async () => {
+        if (params.webhook && !webhookInvoked) {
+            try {
+                await (0, invoke_webhook_1.invokeWebhook)({
+                    url: params.webhook.url,
+                    secret: params.webhook.secret,
+                    payload: {
+                        type: 'timeout',
+                        renderId: params.renderId,
+                        expectedBucketOwner: options.expectedBucketOwner,
+                        bucketName: params.bucketName,
+                    },
+                });
+                webhookInvoked = true;
+            }
+            catch (err) {
+                if (process.env.NODE_ENV === 'test') {
+                    throw err;
+                }
+                await (0, write_lambda_error_1.writeLambdaError)({
+                    bucketName: params.bucketName,
+                    errorInfo: {
+                        type: 'webhook',
+                        message: err.message,
+                        name: err.name,
+                        stack: err.stack,
+                        tmpDir: null,
+                        frame: 0,
+                        chunk: 0,
+                        isFatal: false,
+                        attempt: 1,
+                        willRetry: false,
+                        totalAttempts: 1,
+                    },
+                    renderId: params.renderId,
+                    expectedBucketOwner: options.expectedBucketOwner,
+                });
+                console.log('Failed to invoke webhook:');
+                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)({
@@ -77,12 +144,15 @@ 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 = (_a = params.framesPerLambda) !== null && _a !== void 0 ? _a : (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(frameCount.length);
-    (0, validate_frames_per_lambda_1.validateFramesPerLambda)(framesPerLambda);
+    (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.`);
     }
-    (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)({
@@ -127,6 +197,7 @@ const innerLaunchHandler = async (params, options) => {
             scale: params.scale,
             everyNthFrame: params.everyNthFrame,
             concurrencyPerLambda: params.concurrencyPerLambda,
+            muted: params.muted,
         };
         return payload;
     });
@@ -149,13 +220,37 @@ const innerLaunchHandler = async (params, options) => {
         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,
+        privacy: params.privacy,
     };
+    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);
+    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),
@@ -164,15 +259,11 @@ const innerLaunchHandler = async (params, options) => {
         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);
         callingLambdaTimer.end();
     }));
     reqSend.end();
@@ -202,6 +293,7 @@ const innerLaunchHandler = async (params, options) => {
             privacy: 'private',
             expectedBucketOwner: options.expectedBucketOwner,
             downloadBehavior: null,
+            customCredentials: null,
         }).catch((err) => {
             (0, write_lambda_error_1.writeLambdaError)({
                 bucketName: params.bucketName,
@@ -239,7 +331,6 @@ const innerLaunchHandler = async (params, options) => {
     if (!encodingStop) {
         encodingStop = Date.now();
     }
-    const { key, renderBucketName } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName);
     const outputSize = fs_1.default.statSync(outfile);
     await (0, io_1.lambdaWriteFile)({
         bucketName: renderBucketName,
@@ -249,6 +340,7 @@ const innerLaunchHandler = async (params, options) => {
         privacy: params.privacy,
         expectedBucketOwner: options.expectedBucketOwner,
         downloadBehavior: params.downloadBehavior,
+        customCredentials,
     });
     let chunkProm = Promise.resolve();
     // TODO: Enable in a later release
@@ -271,7 +363,7 @@ const innerLaunchHandler = async (params, options) => {
                     newTiming: (0, get_profile_duration_1.getProfileDuration)(optimizedProfile),
                     createdFromRenderId: params.renderId,
                     framesPerLambda,
-                    lambdaVersion: constants_1.CURRENT_VERSION,
+                    lambdaVersion: version_1.VERSION,
                     frameRange: realFrameRange,
                     everyNthFrame: params.everyNthFrame,
                 },
@@ -311,6 +403,7 @@ const innerLaunchHandler = async (params, options) => {
         privacy: 'private',
         expectedBucketOwner: options.expectedBucketOwner,
         downloadBehavior: null,
+        customCredentials: null,
     });
     const errorExplanationsProm = (0, inspect_errors_1.inspectErrors)({
         contents,
@@ -329,6 +422,7 @@ const innerLaunchHandler = async (params, options) => {
         contents,
         jobs,
     });
+    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)(),
@@ -342,7 +436,7 @@ const innerLaunchHandler = async (params, options) => {
         outputFile: {
             lastModified: Date.now(),
             size: outputSize.size,
-            url: (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(renderMetadata, params.bucketName),
+            url: outputUrl,
         },
     });
     await finalEncodingProgressProm;
@@ -353,9 +447,61 @@ 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,
+                },
+            });
+            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');
     }
@@ -363,6 +509,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,
@@ -382,6 +531,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 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 {};

package/dist/functions/progress.js

@@ -1,20 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.progressHandler = void 0;
+const version_1 = require("remotion/version");
 const constants_1 = require("../shared/constants");
 const get_current_region_1 = require("./helpers/get-current-region");
 const get_progress_1 = require("./helpers/get-progress");
 const progressHandler = (lambdaParams, options) => {
+    var _a;
     if (lambdaParams.type !== constants_1.LambdaRoutines.status) {
         throw new TypeError('Expected status type');
     }
+    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(), get deployed Lambda function had version ${version_1.VERSION} and the @remotion/lambda package has version ${lambdaParams.version}. Align the versions.`);
+    }
     return (0, get_progress_1.getProgress)({
         bucketName: lambdaParams.bucketName,
         renderId: lambdaParams.renderId,
         expectedBucketOwner: options.expectedBucketOwner,
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
-        timeoutInMiliseconds: options.timeoutInMiliseconds,
+        timeoutInMilliseconds: options.timeoutInMilliseconds,
+        customCredentials: (_a = lambdaParams.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
     });
 };
 exports.progressHandler = progressHandler;

package/dist/functions/renderer.js

@@ -18,7 +18,7 @@ const get_folder_size_1 = require("./helpers/get-folder-size");
 const io_1 = require("./helpers/io");
 const write_lambda_error_1 = require("./helpers/write-lambda-error");
 const renderHandler = async (params, options, logs) => {
-    var _a, _b;
+    var _a;
     if (params.type !== constants_1.LambdaRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -41,81 +41,106 @@ const renderHandler = async (params, options, logs) => {
     const outputLocation = path_1.default.join(outdir, `localchunk-${String(params.chunk).padStart(8, '0')}.${renderer_1.RenderInternals.getFileExtensionFromCodec(params.codec, 'chunk')}`);
     const chunkCodec = params.codec === 'gif' ? 'h264-mkv' : params.codec;
     const downloadMap = renderer_1.RenderInternals.makeDownloadMap();
-    await (0, renderer_1.renderMedia)({
-        composition: {
-            id: params.composition,
-            durationInFrames: params.durationInFrames,
-            fps: params.fps,
-            height: params.height,
-            width: params.width,
-        },
-        imageFormat: params.imageFormat,
-        inputProps: params.inputProps,
-        frameRange: params.frameRange,
-        onProgress: ({ renderedFrames, encodedFrames, stitchStage }) => {
-            if (renderedFrames % 10 === 0 &&
-                renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose')) {
-                console.log(`Rendered ${renderedFrames} frames, encoded ${encodedFrames} frames, stage = ${stitchStage}`);
-            }
-            const allFrames = renderer_1.RenderInternals.getFramesToRender(params.frameRange, params.everyNthFrame);
-            if (renderedFrames === allFrames.length) {
-                console.log('Rendered all frames!');
-            }
-            chunkTimingData.timings[renderedFrames] = Date.now() - start;
-        },
-        parallelism: params.concurrencyPerLambda,
-        onStart: () => {
-            (0, io_1.lambdaWriteFile)({
-                privacy: 'private',
-                bucketName: params.bucketName,
-                body: JSON.stringify({
-                    filesCleaned: clean_tmpdir_1.deletedFilesSize,
-                    filesInTmp: fs_1.default.readdirSync('/tmp'),
-                    isWarm: options.isWarm,
-                    deletedFiles: clean_tmpdir_1.deletedFiles,
-                    tmpSize: (0, get_folder_size_1.getFolderSizeRecursively)('/tmp'),
-                    tmpDirFiles: (0, get_files_in_folder_1.getFolderFiles)('/tmp'),
-                }),
-                key: (0, constants_1.lambdaInitializedKey)({
-                    renderId: params.renderId,
-                    chunk: params.chunk,
-                    attempt: params.attempt,
-                }),
-                region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-                expectedBucketOwner: options.expectedBucketOwner,
-                downloadBehavior: null,
-            });
-        },
-        puppeteerInstance: browserInstance,
-        serveUrl: params.serveUrl,
-        quality: params.quality,
-        envVariables: params.envVariables,
-        dumpBrowserLogs: renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose'),
-        verbose: renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose'),
-        onBrowserLog: (log) => {
-            logs.push(log);
-        },
-        outputLocation,
-        codec: chunkCodec,
-        crf: (_b = params.crf) !== null && _b !== void 0 ? _b : undefined,
-        ffmpegExecutable: process.env.NODE_ENV === 'test' ? null : '/opt/bin/ffmpeg',
-        pixelFormat: params.pixelFormat,
-        proResProfile: params.proResProfile,
-        onDownload: (src) => {
-            console.log('Downloading', src);
-            return () => undefined;
-        },
-        overwrite: false,
-        chromiumOptions: params.chromiumOptions,
-        scale: params.scale,
-        timeoutInMilliseconds: params.timeoutInMilliseconds,
-        port: null,
-        everyNthFrame: params.everyNthFrame,
-        numberOfGifLoops: null,
-        downloadMap,
+    const downloads = {};
+    await new Promise((resolve, reject) => {
+        var _a;
+        (0, renderer_1.renderMedia)({
+            composition: {
+                id: params.composition,
+                durationInFrames: params.durationInFrames,
+                fps: params.fps,
+                height: params.height,
+                width: params.width,
+            },
+            imageFormat: params.imageFormat,
+            inputProps: params.inputProps,
+            frameRange: params.frameRange,
+            onProgress: ({ renderedFrames, encodedFrames, stitchStage }) => {
+                if (renderedFrames % 10 === 0 &&
+                    renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose')) {
+                    console.log(`Rendered ${renderedFrames} frames, encoded ${encodedFrames} frames, stage = ${stitchStage}`);
+                }
+                const allFrames = renderer_1.RenderInternals.getFramesToRender(params.frameRange, params.everyNthFrame);
+                if (renderedFrames === allFrames.length) {
+                    console.log('Rendered all frames!');
+                }
+                chunkTimingData.timings[renderedFrames] = Date.now() - start;
+            },
+            concurrency: params.concurrencyPerLambda,
+            onStart: () => {
+                (0, io_1.lambdaWriteFile)({
+                    privacy: 'private',
+                    bucketName: params.bucketName,
+                    body: JSON.stringify({
+                        filesCleaned: clean_tmpdir_1.deletedFilesSize,
+                        filesInTmp: fs_1.default.readdirSync('/tmp'),
+                        isWarm: options.isWarm,
+                        deletedFiles: clean_tmpdir_1.deletedFiles,
+                        tmpSize: (0, get_folder_size_1.getFolderSizeRecursively)('/tmp'),
+                        tmpDirFiles: (0, get_files_in_folder_1.getFolderFiles)('/tmp'),
+                    }),
+                    key: (0, constants_1.lambdaChunkInitializedKey)({
+                        renderId: params.renderId,
+                        chunk: params.chunk,
+                        attempt: params.attempt,
+                    }),
+                    region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+                    expectedBucketOwner: options.expectedBucketOwner,
+                    downloadBehavior: null,
+                    customCredentials: null,
+                }).catch((err) => reject(err));
+            },
+            puppeteerInstance: browserInstance,
+            serveUrl: params.serveUrl,
+            quality: params.quality,
+            envVariables: params.envVariables,
+            dumpBrowserLogs: renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose'),
+            verbose: renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose'),
+            onBrowserLog: (log) => {
+                logs.push(log);
+            },
+            outputLocation,
+            codec: chunkCodec,
+            crf: (_a = params.crf) !== null && _a !== void 0 ? _a : undefined,
+            ffmpegExecutable: process.env.NODE_ENV === 'test' ? null : '/opt/bin/ffmpeg',
+            pixelFormat: params.pixelFormat,
+            proResProfile: params.proResProfile,
+            onDownload: (src) => {
+                console.log('Downloading', src);
+                downloads[src] = 0;
+                return ({ percent, downloaded }) => {
+                    if (percent === null) {
+                        console.log(`Download progress (${src}): ${downloaded} bytes. Don't know final size of download, no Content-Length header.`);
+                        return;
+                    }
+                    if (
+                    // Only report every 10% change
+                    downloads[src] > percent - 0.1 &&
+                        percent !== 1) {
+                        return;
+                    }
+                    downloads[src] = percent;
+                    console.log(`Download progress (${src}): ${downloaded} bytes, ${(percent * 100).toFixed(1)}%`);
+                    if (percent === 1) {
+                        console.log(`Download complete: ${src}`);
+                    }
+                };
+            },
+            overwrite: false,
+            chromiumOptions: params.chromiumOptions,
+            scale: params.scale,
+            timeoutInMilliseconds: params.timeoutInMilliseconds,
+            port: null,
+            everyNthFrame: params.everyNthFrame,
+            numberOfGifLoops: null,
+            downloadMap,
+            muted: params.muted,
+            enforceAudioTrack: true,
+        })
+            .then(() => resolve())
+            .catch((err) => reject(err));
     });
     const endRendered = Date.now();
-    console.log('Adding silent audio, chunk', params.chunk);
     const condensedTimingData = {
         ...chunkTimingData,
         timings: Object.values(chunkTimingData.timings),
@@ -131,6 +156,7 @@ const renderHandler = async (params, options, logs) => {
         privacy: params.privacy,
         expectedBucketOwner: options.expectedBucketOwner,
         downloadBehavior: null,
+        customCredentials: null,
     });
     await Promise.all([
         fs_1.default.promises.rm(outputLocation, { recursive: true }),
@@ -148,6 +174,7 @@ const renderHandler = async (params, options, logs) => {
             privacy: 'private',
             expectedBucketOwner: options.expectedBucketOwner,
             downloadBehavior: null,
+            customCredentials: null,
         }),
     ]);
 };
@@ -160,6 +187,9 @@ const rendererHandler = async (params, options) => {
         await renderHandler(params, options, logs);
     }
     catch (err) {
+        if (process.env.NODE_ENV === 'test') {
+            throw err;
+        }
         // If this error is encountered, we can just retry as it
         // is a very rare error to occur
         const isBrowserError = err.message.includes('FATAL:zygote_communication_linux.cc') ||

package/dist/functions/start.d.ts

@@ -1,5 +1,9 @@
 import type { LambdaPayload } from '../shared/constants';
-export declare const startHandler: (params: LambdaPayload) => Promise<{
+declare type Options = {
+    expectedBucketOwner: string;
+};
+export declare const startHandler: (params: LambdaPayload, options: Options) => Promise<{
     bucketName: string;
     renderId: string;
 }>;
+export {};