@remotion/lambda 3.2.25 → 3.2.26-crf.18

package/dist/api/render-media-on-lambda.d.ts

@@ -8,16 +8,16 @@ export declare type RenderMediaOnLambdaInput = {
     functionName: string;
     serveUrl: string;
     composition: string;
-    inputProps: unknown;
+    inputProps?: unknown;
     codec: LambdaCodec;
-    imageFormat: ImageFormat;
+    imageFormat?: ImageFormat;
     crf?: number | undefined;
     envVariables?: Record<string, string>;
     pixelFormat?: PixelFormat;
     proResProfile?: ProResProfile;
-    privacy: Privacy;
+    privacy?: Privacy;
     quality?: number;
-    maxRetries: number;
+    maxRetries?: number;
     framesPerLambda?: number;
     logLevel?: LogLevel;
     frameRange?: FrameRange;
@@ -31,6 +31,8 @@ export declare type RenderMediaOnLambdaInput = {
     downloadBehavior?: DownloadBehavior | null;
     muted?: boolean;
     overwrite?: boolean;
+    webhook?: string;
+    webhookSecret?: string;
 };
 export declare type RenderMediaOnLambdaOutput = {
     renderId: string;
@@ -45,18 +47,19 @@ export declare type RenderMediaOnLambdaOutput = {
  * @param params.composition The ID of the composition which should be rendered.
  * @param params.inputProps The input props that should be passed to the composition.
  * @param params.codec The media codec which should be used for encoding.
- * @param params.imageFormat In which image format the frames should be rendered.
+ * @param params.imageFormat In which image format the frames should be rendered. Default "jpeg"
  * @param params.crf The constant rate factor to be used during encoding.
  * @param params.envVariables Object containing environment variables to be inserted into the video environment
  * @param params.proResProfile The ProRes profile if rendering a ProRes video
  * @param params.quality JPEG quality if JPEG was selected as the image format.
  * @param params.region The AWS region in which the media should be rendered.
- * @param params.maxRetries How often rendering a chunk may fail before the media render gets aborted.
+ * @param params.maxRetries How often rendering a chunk may fail before the media render gets aborted. Default "1"
  * @param params.logLevel Level of logging that Lambda function should perform. Default "info".
+ * @param params.webhook Webhook URL to be called upon completion or timeout of the rendering process.
  * @returns {Promise<RenderMediaOnLambdaOutput>} See documentation for detailed structure
  */
-export declare const renderMediaOnLambda: ({ functionName, serveUrl, inputProps, codec, imageFormat, crf, envVariables, pixelFormat, proResProfile, quality, region, maxRetries, composition, framesPerLambda, privacy, logLevel, frameRange, outName, timeoutInMilliseconds, chromiumOptions, scale, numberOfGifLoops, everyNthFrame, concurrencyPerLambda, downloadBehavior, muted, overwrite, }: RenderMediaOnLambdaInput) => Promise<RenderMediaOnLambdaOutput>;
+export declare const renderMediaOnLambda: ({ functionName, serveUrl, inputProps, codec, imageFormat, crf, envVariables, pixelFormat, proResProfile, quality, region, maxRetries, composition, framesPerLambda, privacy, logLevel, frameRange, outName, timeoutInMilliseconds, chromiumOptions, scale, numberOfGifLoops, everyNthFrame, concurrencyPerLambda, downloadBehavior, muted, overwrite, webhook, webhookSecret }: RenderMediaOnLambdaInput) => Promise<RenderMediaOnLambdaOutput>;
 /**
  * @deprecated Renamed to renderMediaOnLambda()
  */
-export declare const renderVideoOnLambda: ({ functionName, serveUrl, inputProps, codec, imageFormat, crf, envVariables, pixelFormat, proResProfile, quality, region, maxRetries, composition, framesPerLambda, privacy, logLevel, frameRange, outName, timeoutInMilliseconds, chromiumOptions, scale, numberOfGifLoops, everyNthFrame, concurrencyPerLambda, downloadBehavior, muted, overwrite, }: RenderMediaOnLambdaInput) => Promise<RenderMediaOnLambdaOutput>;
+export declare const renderVideoOnLambda: ({ functionName, serveUrl, inputProps, codec, imageFormat, crf, envVariables, pixelFormat, proResProfile, quality, region, maxRetries, composition, framesPerLambda, privacy, logLevel, frameRange, outName, timeoutInMilliseconds, chromiumOptions, scale, numberOfGifLoops, everyNthFrame, concurrencyPerLambda, downloadBehavior, muted, overwrite, webhook, webhookSecret }: RenderMediaOnLambdaInput) => Promise<RenderMediaOnLambdaOutput>;

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

@@ -18,17 +18,18 @@ const validate_serveurl_1 = require("../shared/validate-serveurl");
  * @param params.composition The ID of the composition which should be rendered.
  * @param params.inputProps The input props that should be passed to the composition.
  * @param params.codec The media codec which should be used for encoding.
- * @param params.imageFormat In which image format the frames should be rendered.
+ * @param params.imageFormat In which image format the frames should be rendered. Default "jpeg"
  * @param params.crf The constant rate factor to be used during encoding.
  * @param params.envVariables Object containing environment variables to be inserted into the video environment
  * @param params.proResProfile The ProRes profile if rendering a ProRes video
  * @param params.quality JPEG quality if JPEG was selected as the image format.
  * @param params.region The AWS region in which the media should be rendered.
- * @param params.maxRetries How often rendering a chunk may fail before the media render gets aborted.
+ * @param params.maxRetries How often rendering a chunk may fail before the media render gets aborted. Default "1"
  * @param params.logLevel Level of logging that Lambda function should perform. Default "info".
+ * @param params.webhook Webhook URL to be called upon completion or timeout of the rendering process.
  * @returns {Promise<RenderMediaOnLambdaOutput>} See documentation for detailed structure
  */
-const renderMediaOnLambda = async ({ functionName, serveUrl, inputProps, codec, imageFormat, crf, envVariables, pixelFormat, proResProfile, quality, region, maxRetries, composition, framesPerLambda, privacy, logLevel, frameRange, outName, timeoutInMilliseconds, chromiumOptions, scale, numberOfGifLoops, everyNthFrame, concurrencyPerLambda, downloadBehavior, muted, overwrite, }) => {
+const renderMediaOnLambda = async ({ functionName, serveUrl, inputProps, codec, imageFormat, crf, envVariables, pixelFormat, proResProfile, quality, region, maxRetries, composition, framesPerLambda, privacy, logLevel, frameRange, outName, timeoutInMilliseconds, chromiumOptions, scale, numberOfGifLoops, everyNthFrame, concurrencyPerLambda, downloadBehavior, muted, overwrite, webhook, webhookSecret }) => {
     var _a;
     const actualCodec = (0, validate_lambda_codec_1.validateLambdaCodec)(codec);
     (0, validate_serveurl_1.validateServeUrl)(serveUrl);
@@ -46,16 +47,16 @@ const renderMediaOnLambda = async ({ functionName, serveUrl, inputProps, codec,
                 framesPerLambda: framesPerLambda !== null && framesPerLambda !== void 0 ? framesPerLambda : null,
                 composition,
                 serveUrl: realServeUrl,
-                inputProps,
+                inputProps: inputProps !== null && inputProps !== void 0 ? inputProps : {},
                 codec: actualCodec,
-                imageFormat,
+                imageFormat: imageFormat !== null && imageFormat !== void 0 ? imageFormat : 'jpeg',
                 crf,
                 envVariables,
                 pixelFormat,
                 proResProfile,
                 quality,
-                maxRetries,
-                privacy,
+                maxRetries: maxRetries !== null && maxRetries !== void 0 ? maxRetries : 1,
+                privacy: privacy !== null && privacy !== void 0 ? privacy : 'public',
                 logLevel: logLevel !== null && logLevel !== void 0 ? logLevel : 'info',
                 frameRange: frameRange !== null && frameRange !== void 0 ? frameRange : null,
                 outName: outName !== null && outName !== void 0 ? outName : null,
@@ -69,6 +70,8 @@ const renderMediaOnLambda = async ({ functionName, serveUrl, inputProps, codec,
                 muted: muted !== null && muted !== void 0 ? muted : false,
                 version: version_1.VERSION,
                 overwrite: overwrite !== null && overwrite !== void 0 ? overwrite : false,
+                webhook,
+                webhookSecret,
             },
             region,
         });

package/dist/cli/args.d.ts

@@ -24,6 +24,8 @@ declare type LambdaCommandLineOptions = {
     ['architecture']: LambdaArchitecture;
     ['custom-role-arn']: string | undefined;
     privacy: Privacy;
+    webhook: string | undefined;
+    webhookSecret: string | undefined;
 };
 export declare const parsedLambdaCli: LambdaCommandLineOptions & minimist.ParsedArgs;
 export declare const forceFlagProvided: boolean;

package/dist/cli/commands/render/render.js

@@ -19,7 +19,7 @@ const log_1 = require("../../log");
 const progress_1 = require("./progress");
 exports.RENDER_COMMAND = 'render';
 const renderCommand = async (args) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const serveUrl = args[0];
     if (!serveUrl) {
         log_1.Log.error('No serve URL passed.');
@@ -36,10 +36,16 @@ const renderCommand = async (args) => {
         log_1.Log.info(`${constants_1.BINARY_NAME} ${exports.RENDER_COMMAND} <serve-url> <composition-id> [output-location]`);
         (0, quit_1.quit)(1);
     }
-    const outName = (_a = args[2]) !== null && _a !== void 0 ? _a : null;
-    const { chromiumOptions, codec, crf, envVariables, frameRange, imageFormat, inputProps, logLevel, pixelFormat, proResProfile, puppeteerTimeout, quality, scale, everyNthFrame, numberOfGifLoops, muted, overwrite, } = await cli_1.CliInternals.getCliOptions({
+    const outName = args_1.parsedLambdaCli['out-name'];
+    const downloadName = (_a = args[2]) !== null && _a !== void 0 ? _a : null;
+    const { codec, reason } = cli_1.CliInternals.getFinalCodec({
+        downloadName,
+        outName: outName !== null && outName !== void 0 ? outName : null,
+    });
+    const { chromiumOptions, crf, envVariables, frameRange, imageFormat, inputProps, logLevel, pixelFormat, proResProfile, puppeteerTimeout, quality, scale, everyNthFrame, numberOfGifLoops, muted, overwrite, } = await cli_1.CliInternals.getCliOptions({
         type: 'series',
         isLambda: true,
+        codec,
     });
     const functionName = await (0, find_function_name_1.findFunctionName)();
     const region = (0, get_aws_region_1.getAwsRegion)();
@@ -76,10 +82,13 @@ const renderCommand = async (args) => {
         concurrencyPerLambda: args_1.parsedLambdaCli['concurrency-per-lambda'],
         muted,
         overwrite,
+        webhook: (_e = args_1.parsedLambdaCli.webhook) !== null && _e !== void 0 ? _e : undefined,
+        webhookSecret: (_f = args_1.parsedLambdaCli.webhookSecret) !== null && _f !== void 0 ? _f : undefined
     });
-    const totalSteps = outName ? 5 : 4;
+    const totalSteps = downloadName ? 5 : 4;
     const progressBar = cli_1.CliInternals.createOverwriteableCliOutput(cli_1.CliInternals.quietFlagProvided());
-    log_1.Log.info(cli_1.CliInternals.chalk.gray(`Bucket = ${res.bucketName}, renderId = ${res.renderId}, functionName = ${functionName}`));
+    log_1.Log.info(cli_1.CliInternals.chalk.gray(`bucket = ${res.bucketName}, function = ${functionName}`));
+    log_1.Log.info(cli_1.CliInternals.chalk.gray(`renderId = ${res.renderId}, codec = ${codec} (${reason})`));
     log_1.Log.verbose(`CloudWatch logs (if enabled): ${res.cloudWatchLogs}`);
     const status = await (0, get_render_progress_1.getRenderProgress)({
         functionName,
@@ -117,11 +126,11 @@ const renderCommand = async (args) => {
                 downloadInfo: null,
                 retriesInfo: newStatus.retriesInfo,
             }));
-            if (outName) {
+            if (downloadName) {
                 const downloadStart = Date.now();
                 const { outputPath, sizeInBytes } = await (0, download_media_1.downloadMedia)({
                     bucketName: res.bucketName,
-                    outPath: outName,
+                    outPath: downloadName,
                     region: (0, get_aws_region_1.getAwsRegion)(),
                     renderId: res.renderId,
                     onProgress: ({ downloaded, totalSize }) => {

package/dist/cli/commands/still.js

@@ -15,7 +15,7 @@ const quit_1 = require("../helpers/quit");
 const log_1 = require("../log");
 exports.STILL_COMMAND = 'still';
 const stillCommand = async (args) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const serveUrl = args[0];
     if (!serveUrl) {
         log_1.Log.error('No serve URL passed.');
@@ -32,22 +32,32 @@ const stillCommand = async (args) => {
         log_1.Log.info(`${constants_1.BINARY_NAME} ${exports.STILL_COMMAND} <serve-url> <composition-id> [output-location]`);
         (0, quit_1.quit)(1);
     }
-    const outName = (_a = args[2]) !== null && _a !== void 0 ? _a : null;
-    const { chromiumOptions, envVariables, imageFormat, inputProps, logLevel, puppeteerTimeout, quality, stillFrame, scale, } = await cli_1.CliInternals.getCliOptions({
+    const downloadName = (_a = args[2]) !== null && _a !== void 0 ? _a : null;
+    const outName = args_1.parsedLambdaCli['out-name'];
+    const { chromiumOptions, envVariables, inputProps, logLevel, puppeteerTimeout, quality, stillFrame, scale, } = await cli_1.CliInternals.getCliOptions({
         type: 'still',
         isLambda: true,
+        codec: 'h264',
     });
     const functionName = await (0, find_function_name_1.findFunctionName)();
     const maxRetries = (_b = args_1.parsedLambdaCli['max-retries']) !== null && _b !== void 0 ? _b : constants_1.DEFAULT_MAX_RETRIES;
     (0, validate_retries_1.validateMaxRetries)(maxRetries);
     const privacy = (_c = args_1.parsedLambdaCli.privacy) !== null && _c !== void 0 ? _c : constants_1.DEFAULT_OUTPUT_PRIVACY;
     (0, validate_privacy_1.validatePrivacy)(privacy);
+    const { format: imageFormat, source: imageFormatReason } = cli_1.CliInternals.determineFinalImageFormat({
+        downloadName,
+        outName: outName !== null && outName !== void 0 ? outName : null,
+        configImageFormat: (_d = cli_1.ConfigInternals.getUserPreferredImageFormat()) !== null && _d !== void 0 ? _d : null,
+        cliFlag: (_e = cli_1.CliInternals.parsedCli['image-format']) !== null && _e !== void 0 ? _e : null,
+        isLambda: true,
+    });
     try {
+        log_1.Log.info(cli_1.CliInternals.chalk.gray(`functionName = ${functionName}, imageFormat = ${imageFormat} (${imageFormatReason})`));
         const res = await (0, render_still_on_lambda_1.renderStillOnLambda)({
             functionName,
             serveUrl,
             inputProps,
-            imageFormat: imageFormat,
+            imageFormat,
             composition,
             privacy,
             region: (0, get_aws_region_1.getAwsRegion)(),
@@ -56,18 +66,18 @@ const stillCommand = async (args) => {
             frame: stillFrame,
             quality,
             logLevel,
-            outName: args_1.parsedLambdaCli['out-name'],
+            outName,
             chromiumOptions,
             timeoutInMilliseconds: puppeteerTimeout,
             scale,
         });
-        log_1.Log.verbose(cli_1.CliInternals.chalk.gray(`Bucket = ${res.bucketName}, renderId = ${res.renderId}, functionName = ${functionName}`));
+        log_1.Log.info(cli_1.CliInternals.chalk.gray(`Bucket = ${res.bucketName}, renderId = ${res.renderId}`));
         log_1.Log.verbose(`CloudWatch logs (if enabled): ${res.cloudWatchLogs}`);
-        if (outName) {
+        if (downloadName) {
             log_1.Log.info('Finished rendering. Downloading...');
             const { outputPath, sizeInBytes } = await (0, download_media_1.downloadMedia)({
                 bucketName: res.bucketName,
-                outPath: outName,
+                outPath: downloadName,
                 region: (0, get_aws_region_1.getAwsRegion)(),
                 renderId: res.renderId,
             });
@@ -80,7 +90,7 @@ const stillCommand = async (args) => {
         }
     }
     catch (err) {
-        const frames = renderer_1.RenderInternals.parseStack(((_d = err.stack) !== null && _d !== void 0 ? _d : '').split('\n'));
+        const frames = renderer_1.RenderInternals.parseStack(((_f = err.stack) !== null && _f !== void 0 ? _f : '').split('\n'));
         const errorWithStackFrame = new renderer_1.RenderInternals.SymbolicateableError({
             message: err.message,
             frame: null,

package/dist/cli/helpers/get-cloudwatch-stream-url.d.ts

@@ -0,0 +1,8 @@
+import type { AwsRegion } from '../../client';
+import type { LambdaRoutines } from '../../shared/constants';
+export declare const getCloudwatchStreamUrl: ({ region, functionName, method, renderId, }: {
+    region: AwsRegion;
+    functionName: string;
+    method: LambdaRoutines;
+    renderId: string;
+}) => string;

package/dist/cli/helpers/get-cloudwatch-stream-url.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCloudwatchStreamUrl = void 0;
+const getCloudwatchStreamUrl = ({ region, functionName, method, renderId, }) => {
+    return `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:log-groups/log-group/$252Faws$252Flambda$252F${functionName}/log-events$3FfilterPattern$3D$2522method$253D${method}$252CrenderId$253D${renderId}$2522`;
+};
+exports.getCloudwatchStreamUrl = getCloudwatchStreamUrl;

package/dist/cli/index.js

@@ -133,7 +133,7 @@ AWS returned an "TooManyRequestsException" error message which could mean you re
 };
 exports.executeCommand = executeCommand;
 const cli = async () => {
-    await cli_1.CliInternals.initializeRenderCli(cli_1.CliInternals.findRemotionRoot(), 'lambda');
+    await cli_1.CliInternals.initializeCli(cli_1.CliInternals.findRemotionRoot());
     await (0, exports.executeCommand)(args_1.parsedLambdaCli._);
 };
 exports.cli = cli;

package/dist/functions/chunk-optimization/plan-frame-ranges.d.ts

@@ -6,9 +6,6 @@ export declare const planFrameRanges: ({ framesPerLambda, optimization, shouldUs
     frameRange: [number, number];
     everyNthFrame: number;
 }) => {
-    chunks: [
-        number,
-        number
-    ][];
+    chunks: [number, number][];
     didUseOptimization: boolean;
 };

package/dist/functions/helpers/write-lambda-error.d.ts

@@ -1,6 +1,6 @@
 import type { FileNameAndSize } from './get-files-in-folder';
 export declare type LambdaErrorInfo = {
-    type: 'renderer' | 'browser' | 'stitcher';
+    type: 'renderer' | 'browser' | 'stitcher' | 'webhook';
     message: string;
     name: string;
     stack: string;

package/dist/functions/launch.js

@@ -12,6 +12,7 @@ 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");
@@ -68,6 +69,52 @@ const innerLaunchHandler = async (params, options) => {
         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,
+                    secret: params.webhookSecret,
+                    type: 'timeout',
+                    renderId: params.renderId,
+                    expectedBucketOwner: options.expectedBucketOwner,
+                    bucketName: params.bucketName,
+                    outputUrl: undefined,
+                    errors: [],
+                    lambdaErrors: [],
+                    outputFile: undefined,
+                    timeToFinish: undefined,
+                });
+                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)({
@@ -108,7 +155,7 @@ const innerLaunchHandler = async (params, options) => {
     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)({
@@ -378,6 +425,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)(),
@@ -391,7 +439,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, customCredentials),
+            url: outputUrl,
         },
     });
     await finalEncodingProgressProm;
@@ -409,6 +457,50 @@ const innerLaunchHandler = async (params, options) => {
         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,
+                secret: params.webhookSecret,
+                type: 'success',
+                renderId: params.renderId,
+                expectedBucketOwner: options.expectedBucketOwner,
+                bucketName: params.bucketName,
+                outputUrl,
+                errors: [],
+                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) => {
     if (params.type !== constants_1.LambdaRoutines.launch) {
@@ -418,6 +510,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,
@@ -437,6 +532,48 @@ const launchHandler = async (params, options) => {
             expectedBucketOwner: options.expectedBucketOwner,
             renderId: params.renderId,
         });
+        if (params.webhook) {
+            try {
+                await (0, invoke_webhook_1.invokeWebhook)({
+                    url: params.webhook,
+                    secret: params.webhookSecret,
+                    type: 'error',
+                    renderId: params.renderId,
+                    expectedBucketOwner: options.expectedBucketOwner,
+                    bucketName: params.bucketName,
+                    lambdaErrors: [],
+                    errors: [err],
+                    outputUrl: undefined,
+                    outputFile: undefined,
+                    timeToFinish: undefined,
+                });
+            }
+            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/renderer.js

@@ -187,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.js

@@ -63,6 +63,8 @@ const startHandler = async (params, options) => {
         downloadBehavior: params.downloadBehavior,
         muted: params.muted,
         overwrite: params.overwrite,
+        webhook: params.webhook,
+        webhookSecret: params.webhookSecret,
     };
     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,

package/dist/functions/still.js

@@ -101,7 +101,10 @@ const innerStillHandler = async (lambdaParams, renderId, options) => {
         serveUrl: lambdaParams.serveUrl,
         dumpBrowserLogs: false,
         envVariables: lambdaParams.envVariables,
-        frame: lambdaParams.frame,
+        frame: renderer_1.RenderInternals.convertToPositiveFrameIndex({
+            frame: lambdaParams.frame,
+            durationInFrames: composition.durationInFrames,
+        }),
         imageFormat: lambdaParams.imageFormat,
         inputProps: lambdaParams.inputProps,
         overwrite: false,

package/dist/shared/constants.d.ts

@@ -125,6 +125,8 @@ export declare type LambdaPayloads = {
         muted: boolean;
         version: string;
         overwrite: boolean;
+        webhook: string | undefined;
+        webhookSecret: string | undefined;
     };
     launch: {
         type: LambdaRoutines.launch;
@@ -155,6 +157,8 @@ export declare type LambdaPayloads = {
         downloadBehavior: DownloadBehavior;
         muted: boolean;
         overwrite: boolean;
+        webhook: string | undefined;
+        webhookSecret: string | undefined;
     };
     status: {
         type: LambdaRoutines.status;

package/dist/shared/invoke-webhook.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import http from 'http';
+import https from 'https';
+import type { EnhancedErrorInfo } from '../functions/helpers/write-lambda-error';
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+export declare function calculateSignature(payload: string, secret?: string): string;
+export declare type InvokeWebhookInput = {
+    url: string;
+    type: 'success' | 'error' | 'timeout';
+    renderId: string;
+    secret: string | undefined;
+    expectedBucketOwner: string;
+    bucketName: string;
+    outputUrl: string | undefined;
+    lambdaErrors: EnhancedErrorInfo[];
+    errors: Error[];
+    outputFile: string | undefined;
+    timeToFinish: number | undefined;
+};
+export declare const mockableHttpClients: {
+    http: typeof http.request;
+    https: typeof https.request;
+};
+/**
+ * @description Calls a webhook.
+ * @link https://remotion.dev/docs/lambda/rendermediaonlambda#webhook
+ * @param params.url URL of webhook to call.
+ * @param params.renderId assigned render ID.
+ * @param params.secret webhook secret provided by the user.
+ * @param params.bucketName S3 bucket name.
+ * @param params.expectedBucketOwner owner of S3 bucket.
+ * @param params.outputUrl URL of rendered media file.
+ * @param params.lambdaErrors non-fatal errors that have occurred during the render process.
+ * @param params.errors fatal errors that have been thrown during the render process.
+ * @param params.outputFile output file.
+ * @param params.timeToFinish time to finish of rendering process.
+ * @returns {Promise<void>} Promise of HTTP request with resolve/reject to be used for error handling.
+ */
+export declare function invokeWebhook({ url, type, renderId, secret, bucketName, expectedBucketOwner, outputUrl, lambdaErrors, errors, outputFile, timeToFinish, }: InvokeWebhookInput): Promise<void>;

package/dist/shared/invoke-webhook.js

@@ -0,0 +1,117 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeWebhook = exports.mockableHttpClients = exports.calculateSignature = void 0;
+const Crypto = __importStar(require("crypto"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+function calculateSignature(payload, secret) {
+    if (!secret) {
+        return 'NO_SECRET_PROVIDED';
+    }
+    const hmac = Crypto.createHmac('sha512', secret);
+    const signature = 'sha512=' + hmac.update(payload).digest('hex');
+    return signature;
+}
+exports.calculateSignature = calculateSignature;
+const getWebhookClient = (url) => {
+    if (url.startsWith('https://')) {
+        return exports.mockableHttpClients.https;
+    }
+    if (url.startsWith('http://')) {
+        return exports.mockableHttpClients.http;
+    }
+    throw new Error('Can only request URLs starting with http:// or https://');
+};
+exports.mockableHttpClients = {
+    http: http_1.default.request,
+    https: https_1.default.request,
+};
+/**
+ * @description Calls a webhook.
+ * @link https://remotion.dev/docs/lambda/rendermediaonlambda#webhook
+ * @param params.url URL of webhook to call.
+ * @param params.renderId assigned render ID.
+ * @param params.secret webhook secret provided by the user.
+ * @param params.bucketName S3 bucket name.
+ * @param params.expectedBucketOwner owner of S3 bucket.
+ * @param params.outputUrl URL of rendered media file.
+ * @param params.lambdaErrors non-fatal errors that have occurred during the render process.
+ * @param params.errors fatal errors that have been thrown during the render process.
+ * @param params.outputFile output file.
+ * @param params.timeToFinish time to finish of rendering process.
+ * @returns {Promise<void>} Promise of HTTP request with resolve/reject to be used for error handling.
+ */
+function invokeWebhook({ url, type, renderId, secret, bucketName, expectedBucketOwner, outputUrl, lambdaErrors, errors, outputFile, timeToFinish, }) {
+    const payload = JSON.stringify({
+        result: type,
+        renderId,
+        bucketName,
+        expectedBucketOwner,
+        outputUrl,
+        outputFile,
+        timeToFinish,
+        lambdaErrors,
+        errors: errors.map((err) => ({
+            message: err.message,
+            name: err.name,
+            stack: err.stack,
+        })),
+    });
+    return new Promise((resolve, reject) => {
+        const req = getWebhookClient(url)(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                "X-Remotion-Mode": 'production',
+                'X-Remotion-Signature': calculateSignature(payload, secret),
+                'X-Remotion-Status': type,
+            },
+            timeout: 5000,
+        }, (res) => {
+            if (res.statusCode && res.statusCode > 299) {
+                reject(new Error(`Sent a webhook but got a status code of ${res.statusCode} with message '${res.statusMessage}'`));
+                return;
+            }
+            resolve();
+        });
+        req.write(payload);
+        req.on('error', (err) => {
+            reject(err);
+        });
+        req.end();
+    });
+}
+exports.invokeWebhook = invokeWebhook;

package/dist/shared/validate-outname.d.ts

@@ -1,2 +1,3 @@
+import type { Codec } from '@remotion/renderer';
 import type { OutNameInputWithoutCredentials } from './constants';
-export declare const validateOutname: (outName: OutNameInputWithoutCredentials | undefined | null) => void;
+export declare const validateOutname: (outName: OutNameInputWithoutCredentials | undefined | null, codec?: Codec) => void;

package/dist/shared/validate-outname.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateOutname = void 0;
+const renderer_1 = require("@remotion/renderer");
 const validate_bucketname_1 = require("./validate-bucketname");
 const validateS3Key = (s3Key) => {
     if (typeof s3Key !== 'string') {
@@ -12,11 +13,14 @@ const validateS3Key = (s3Key) => {
             '. Check for invalid characters.');
     }
 };
-const validateOutname = (outName) => {
+const validateOutname = (outName, codec) => {
     if (typeof outName === 'undefined' || outName === null) {
         return;
     }
     if (typeof outName === 'string') {
+        if (codec) {
+            (0, renderer_1.validateOutputFilename)(codec, renderer_1.RenderInternals.getExtensionOfFilename(outName !== null && outName !== void 0 ? outName : null));
+        }
         validateS3Key(outName);
         return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/lambda",
-	"version": "3.2.25",
+	"version": "3.2.26-crf.18+b22217116",
 	"description": "Distributed renderer for Remotion based on AWS Lambda",
 	"main": "dist/index.js",
 	"sideEffects": false,
@@ -9,7 +9,7 @@
 	},
 	"module": "true",
 	"scripts": {
-		"testintegration": "jest src/test/integration --runInBand",
+		"testintegration": "jest src/test/integration --runInBand --forceExit",
 		"lint": "eslint src --ext ts,tsx",
 		"test": "jest src/test/unit",
 		"watch": "tsc -w",
@@ -32,12 +32,12 @@
 		"@aws-sdk/client-service-quotas": "3.58.0",
 		"@aws-sdk/lib-storage": "3.58.0",
 		"@aws-sdk/s3-request-presigner": "3.58.0",
-		"@remotion/bundler": "3.2.25",
-		"@remotion/cli": "3.2.25",
-		"@remotion/renderer": "3.2.25",
+		"@remotion/bundler": "3.2.26-crf.18+b22217116",
+		"@remotion/cli": "3.2.26-crf.18+b22217116",
+		"@remotion/renderer": "3.2.26-crf.18+b22217116",
 		"aws-policies": "^1.0.1",
 		"mime-types": "2.1.34",
-		"remotion": "3.2.25"
+		"remotion": "3.2.26-crf.18+b22217116"
 	},
 	"peerDependencies": {
 		"react": ">=16.8.0",
@@ -62,5 +62,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "8e51d998e16f062336d65469cbfc9266068b7701"
+	"gitHead": "b222171164aefac1d44e1ad9e08231e9bad9a029"
 }