@remotion/lambda 4.0.0-prefetch.11 → 4.0.0-prefetch.12

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/helpers/write-lambda-error.js

@@ -34,6 +34,7 @@ const writeLambdaError = async ({ bucketName, renderId, errorInfo, expectedBucke
         privacy: 'private',
         expectedBucketOwner,
         downloadBehavior: null,
+        customCredentials: null,
     });
 };
 exports.writeLambdaError = writeLambdaError;

package/dist/functions/helpers/write-post-render-data.js

@@ -12,6 +12,7 @@ const writePostRenderData = async ({ bucketName, renderId, postRenderData, expec
         expectedBucketOwner,
         region,
         downloadBehavior: null,
+        customCredentials: null,
     });
 };
 exports.writePostRenderData = writePostRenderData;

package/dist/functions/index.js

@@ -14,7 +14,7 @@ const start_1 = require("./start");
 const still_1 = require("./still");
 const handler = async (params, context) => {
     process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
-    const timeoutInMiliseconds = context.getRemainingTimeInMillis();
+    const timeoutInMilliseconds = context.getRemainingTimeInMillis();
     if (!context || !context.invokedFunctionArn) {
         throw new Error('Lambda function unexpectedly does not have context.invokedFunctionArn');
     }
@@ -53,7 +53,7 @@ const handler = async (params, context) => {
         });
         return (0, progress_1.progressHandler)(params, {
             expectedBucketOwner: currentUserId,
-            timeoutInMiliseconds,
+            timeoutInMilliseconds,
         });
     }
     if (params.type === constants_1.LambdaRoutines.renderer) {

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");
@@ -29,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");
@@ -62,11 +64,54 @@ const callFunctionWithRetry = async (payload, retries = 0) => {
     }
 };
 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)({
@@ -95,16 +140,21 @@ const innerLaunchHandler = async (params, options) => {
     remotion_1.Internals.validateFps(comp.fps, 'passed to a Lambda render', false);
     remotion_1.Internals.validateDimension(comp.height, 'height', 'passed to a Lambda render');
     remotion_1.Internals.validateDimension(comp.width, 'width', 'passed to a Lambda render');
+    renderer_1.RenderInternals.validateBitrate(params.audioBitrate, 'audioBitrate');
+    renderer_1.RenderInternals.validateBitrate(params.videoBitrate, 'videoBitrate');
     renderer_1.RenderInternals.validateConcurrency(params.concurrencyPerLambda, 'concurrencyPerLambda');
     const realFrameRange = renderer_1.RenderInternals.getRealFrameRange(comp.durationInFrames, params.frameRange);
     const frameCount = renderer_1.RenderInternals.getFramesToRender(realFrameRange, params.everyNthFrame);
     const framesPerLambda = (_a = params.framesPerLambda) !== null && _a !== void 0 ? _a : (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(frameCount.length);
-    (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)({
@@ -150,6 +200,8 @@ const innerLaunchHandler = async (params, options) => {
             everyNthFrame: params.everyNthFrame,
             concurrencyPerLambda: params.concurrencyPerLambda,
             muted: params.muted,
+            audioBitrate: params.audioBitrate,
+            videoBitrate: params.videoBitrate,
         };
         return payload;
     });
@@ -178,7 +230,31 @@ const innerLaunchHandler = async (params, options) => {
         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),
@@ -187,6 +263,7 @@ 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);
@@ -220,6 +297,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,
@@ -241,6 +319,32 @@ const innerLaunchHandler = async (params, options) => {
             });
         });
     };
+    const onErrors = async (errors) => {
+        var _a;
+        console.log('Found Errors', errors);
+        if (params.webhook) {
+            console.log('Sending webhook with errors');
+            await (0, invoke_webhook_1.invokeWebhook)({
+                url: params.webhook.url,
+                secret: (_a = params.webhook.secret) !== null && _a !== void 0 ? _a : null,
+                payload: {
+                    type: 'error',
+                    renderId: params.renderId,
+                    expectedBucketOwner: options.expectedBucketOwner,
+                    bucketName: params.bucketName,
+                    errors: errors.slice(0, 5).map((e) => ({
+                        message: e.message,
+                        name: e.name,
+                        stack: e.stack,
+                    })),
+                },
+            });
+        }
+        else {
+            console.log('No webhook specified');
+        }
+        throw new Error('Stopping Lambda function because error occurred: ' + errors[0].stack);
+    };
     const fps = comp.fps / params.everyNthFrame;
     const { outfile, cleanupChunksProm, encodingStart } = await (0, concat_videos_1.concatVideosS3)({
         bucket: params.bucketName,
@@ -253,11 +357,11 @@ const innerLaunchHandler = async (params, options) => {
         expectedBucketOwner: options.expectedBucketOwner,
         fps,
         numberOfGifLoops: params.numberOfGifLoops,
+        onErrors,
     });
     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,
@@ -267,6 +371,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
@@ -329,6 +434,7 @@ const innerLaunchHandler = async (params, options) => {
         privacy: 'private',
         expectedBucketOwner: options.expectedBucketOwner,
         downloadBehavior: null,
+        customCredentials: null,
     });
     const errorExplanationsProm = (0, inspect_errors_1.inspectErrors)({
         contents,
@@ -347,6 +453,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)(),
@@ -360,7 +467,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;
@@ -375,10 +482,57 @@ const innerLaunchHandler = async (params, options) => {
         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');
     }
@@ -386,6 +540,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,
@@ -405,6 +562,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

@@ -6,6 +6,7 @@ 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');
     }
@@ -21,7 +22,8 @@ const progressHandler = (lambdaParams, options) => {
         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

@@ -66,7 +66,7 @@ const renderHandler = async (params, options, logs) => {
                 }
                 chunkTimingData.timings[renderedFrames] = Date.now() - start;
             },
-            parallelism: params.concurrencyPerLambda,
+            concurrency: params.concurrencyPerLambda,
             onStart: () => {
                 (0, io_1.lambdaWriteFile)({
                     privacy: 'private',
@@ -87,6 +87,7 @@ const renderHandler = async (params, options, logs) => {
                     region: (0, get_current_region_1.getCurrentRegionInFunction)(),
                     expectedBucketOwner: options.expectedBucketOwner,
                     downloadBehavior: null,
+                    customCredentials: null,
                 }).catch((err) => reject(err));
             },
             puppeteerInstance: browserInstance,
@@ -135,6 +136,15 @@ const renderHandler = async (params, options, logs) => {
             downloadMap,
             muted: params.muted,
             enforceAudioTrack: true,
+            audioBitrate: params.audioBitrate,
+            videoBitrate: params.videoBitrate,
+            onSlowestFrames: (slowestFrames) => {
+                console.log();
+                console.log(`Slowest frames:`);
+                slowestFrames.forEach(({ frame, time }) => {
+                    console.log(`Frame ${frame} (${time.toFixed(3)}ms)`);
+                });
+            },
         })
             .then(() => resolve())
             .catch((err) => reject(err));
@@ -155,6 +165,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 }),
@@ -172,6 +183,7 @@ const renderHandler = async (params, options, logs) => {
             privacy: 'private',
             expectedBucketOwner: options.expectedBucketOwner,
             downloadBehavior: null,
+            customCredentials: null,
         }),
     ]);
 };
@@ -184,6 +196,10 @@ const rendererHandler = async (params, options) => {
         await renderHandler(params, options, logs);
     }
     catch (err) {
+        if (process.env.NODE_ENV === 'test') {
+            console.log({ err });
+            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

@@ -32,6 +32,7 @@ const startHandler = async (params, options) => {
         expectedBucketOwner: options.expectedBucketOwner,
         key: (0, constants_1.initalizedMetadataKey)(renderId),
         privacy: 'private',
+        customCredentials: null,
     });
     const payload = {
         type: constants_1.LambdaRoutines.launch,
@@ -61,6 +62,10 @@ const startHandler = async (params, options) => {
         concurrencyPerLambda: params.concurrencyPerLambda,
         downloadBehavior: params.downloadBehavior,
         muted: params.muted,
+        overwrite: params.overwrite,
+        webhook: params.webhook,
+        audioBitrate: params.audioBitrate,
+        videoBitrate: params.videoBitrate,
     };
     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

@@ -83,6 +83,7 @@ const innerStillHandler = async (lambdaParams, renderId, options) => {
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         renderId,
         outName: (_b = lambdaParams.outName) !== null && _b !== void 0 ? _b : undefined,
+        privacy: lambdaParams.privacy,
     };
     await (0, io_1.lambdaWriteFile)({
         bucketName,
@@ -92,6 +93,7 @@ const innerStillHandler = async (lambdaParams, renderId, options) => {
         privacy: 'private',
         expectedBucketOwner: options.expectedBucketOwner,
         downloadBehavior: null,
+        customCredentials: null,
     });
     await (0, renderer_1.renderStill)({
         composition,
@@ -99,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,
@@ -110,7 +115,7 @@ const innerStillHandler = async (lambdaParams, renderId, options) => {
         timeoutInMilliseconds: lambdaParams.timeoutInMilliseconds,
         downloadMap,
     });
-    const { key, renderBucketName } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, bucketName);
+    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, bucketName, (0, expected_out_name_1.getCredentialsFromOutName)(lambdaParams.outName));
     const { size } = await fs_1.default.promises.stat(outputPath);
     await (0, io_1.lambdaWriteFile)({
         bucketName: renderBucketName,
@@ -120,6 +125,7 @@ const innerStillHandler = async (lambdaParams, renderId, options) => {
         expectedBucketOwner: options.expectedBucketOwner,
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         downloadBehavior: lambdaParams.downloadBehavior,
+        customCredentials,
     });
     await fs_1.default.promises.rm(outputPath, { recursive: true });
     const estimatedPrice = (0, estimate_price_1.estimatePrice)({
@@ -133,7 +139,7 @@ const innerStillHandler = async (lambdaParams, renderId, options) => {
         diskSizeInMb: constants_1.MAX_EPHEMERAL_STORAGE_IN_MB,
     });
     return {
-        output: (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(renderMetadata, bucketName),
+        output: (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(renderMetadata, bucketName, customCredentials),
         size,
         bucketName,
         estimatedPrice: (0, format_costs_info_1.formatCostsInfo)(estimatedPrice),

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import type { DeleteFunctionInput } from './api/delete-function';
 import { deleteFunction } from './api/delete-function';
+import { deleteRender } from './api/delete-render';
 import type { DeleteSiteInput, DeleteSiteOutput } from './api/delete-site';
 import { deleteSite } from './api/delete-site';
 import type { DeployFunctionInput, DeployFunctionOutput } from './api/deploy-function';
@@ -31,10 +32,14 @@ import type { RenderMediaOnLambdaInput, RenderMediaOnLambdaOutput } from './api/
 import { renderMediaOnLambda, renderVideoOnLambda } from './api/render-media-on-lambda';
 import type { RenderStillOnLambdaInput, RenderStillOnLambdaOutput } from './api/render-still-on-lambda';
 import { renderStillOnLambda } from './api/render-still-on-lambda';
+import { validateWebhookSignature } from './api/validate-webhook-signature';
 import type { LambdaLSInput, LambdaLsReturnType } from './functions/helpers/io';
+import type { EnhancedErrorInfo, LambdaErrorInfo } from './functions/helpers/write-lambda-error';
 import { LambdaInternals } from './internals';
 import type { AwsRegion } from './pricing/aws-regions';
+import type { CustomCredentials } from './shared/aws-clients';
 import type { RenderProgress } from './shared/constants';
+import type { WebhookPayload } from './shared/invoke-webhook';
 import type { LambdaArchitecture } from './shared/validate-architecture';
-export { deleteSite, deployFunction, deploySite, downloadMedia, downloadVideo, getFunctions, getUserPolicy, getRolePolicy, getSites, getOrCreateBucket, getRenderProgress, renderVideoOnLambda, renderMediaOnLambda, simulatePermissions, deleteFunction, getFunctionInfo, estimatePrice, LambdaInternals, renderStillOnLambda, getRegions, getAwsClient, presignUrl, };
-export type { AwsRegion, RenderProgress, DeploySiteInput, DeploySiteOutput, LambdaLsReturnType, LambdaLSInput, DeleteSiteInput, DeleteSiteOutput, EstimatePriceInput, DeployFunctionInput, DeployFunctionOutput, DeleteFunctionInput, GetFunctionInfoInput, FunctionInfo, GetFunctionsInput, GetSitesInput, GetSitesOutput, DownloadMediaInput, DownloadMediaOutput, GetOrCreateBucketInput, GetOrCreateBucketOutput, GetRenderInput, RenderMediaOnLambdaInput, RenderMediaOnLambdaOutput, RenderStillOnLambdaInput, RenderStillOnLambdaOutput, SimulatePermissionsInput, SimulatePermissionsOutput, GetAwsClientInput, GetAwsClientOutput, LambdaArchitecture, };
+export { deleteSite, deployFunction, deploySite, downloadMedia, downloadVideo, getFunctions, getUserPolicy, getRolePolicy, getSites, getOrCreateBucket, getRenderProgress, renderVideoOnLambda, renderMediaOnLambda, simulatePermissions, deleteFunction, getFunctionInfo, estimatePrice, LambdaInternals, renderStillOnLambda, getRegions, getAwsClient, presignUrl, deleteRender, validateWebhookSignature, };
+export type { AwsRegion, RenderProgress, DeploySiteInput, DeploySiteOutput, LambdaLsReturnType, LambdaLSInput, DeleteSiteInput, DeleteSiteOutput, EstimatePriceInput, DeployFunctionInput, DeployFunctionOutput, DeleteFunctionInput, GetFunctionInfoInput, FunctionInfo, GetFunctionsInput, GetSitesInput, GetSitesOutput, DownloadMediaInput, DownloadMediaOutput, GetOrCreateBucketInput, GetOrCreateBucketOutput, GetRenderInput, RenderMediaOnLambdaInput, RenderMediaOnLambdaOutput, RenderStillOnLambdaInput, RenderStillOnLambdaOutput, SimulatePermissionsInput, SimulatePermissionsOutput, GetAwsClientInput, GetAwsClientOutput, LambdaArchitecture, CustomCredentials, WebhookPayload, LambdaErrorInfo, EnhancedErrorInfo, };

package/dist/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.presignUrl = exports.getAwsClient = exports.getRegions = exports.renderStillOnLambda = exports.LambdaInternals = exports.estimatePrice = exports.getFunctionInfo = exports.deleteFunction = exports.simulatePermissions = exports.renderMediaOnLambda = exports.renderVideoOnLambda = exports.getRenderProgress = exports.getOrCreateBucket = exports.getSites = exports.getRolePolicy = exports.getUserPolicy = exports.getFunctions = exports.downloadVideo = exports.downloadMedia = exports.deploySite = exports.deployFunction = exports.deleteSite = void 0;
+exports.validateWebhookSignature = exports.deleteRender = exports.presignUrl = exports.getAwsClient = exports.getRegions = exports.renderStillOnLambda = exports.LambdaInternals = exports.estimatePrice = exports.getFunctionInfo = exports.deleteFunction = exports.simulatePermissions = exports.renderMediaOnLambda = exports.renderVideoOnLambda = exports.getRenderProgress = exports.getOrCreateBucket = exports.getSites = exports.getRolePolicy = exports.getUserPolicy = exports.getFunctions = exports.downloadVideo = exports.downloadMedia = exports.deploySite = exports.deployFunction = exports.deleteSite = void 0;
 const delete_function_1 = require("./api/delete-function");
 Object.defineProperty(exports, "deleteFunction", { enumerable: true, get: function () { return delete_function_1.deleteFunction; } });
+const delete_render_1 = require("./api/delete-render");
+Object.defineProperty(exports, "deleteRender", { enumerable: true, get: function () { return delete_render_1.deleteRender; } });
 const delete_site_1 = require("./api/delete-site");
 Object.defineProperty(exports, "deleteSite", { enumerable: true, get: function () { return delete_site_1.deleteSite; } });
 const deploy_function_1 = require("./api/deploy-function");
@@ -40,5 +42,7 @@ Object.defineProperty(exports, "renderMediaOnLambda", { enumerable: true, get: f
 Object.defineProperty(exports, "renderVideoOnLambda", { enumerable: true, get: function () { return render_media_on_lambda_1.renderVideoOnLambda; } });
 const render_still_on_lambda_1 = require("./api/render-still-on-lambda");
 Object.defineProperty(exports, "renderStillOnLambda", { enumerable: true, get: function () { return render_still_on_lambda_1.renderStillOnLambda; } });
+const validate_webhook_signature_1 = require("./api/validate-webhook-signature");
+Object.defineProperty(exports, "validateWebhookSignature", { enumerable: true, get: function () { return validate_webhook_signature_1.validateWebhookSignature; } });
 const internals_1 = require("./internals");
 Object.defineProperty(exports, "LambdaInternals", { enumerable: true, get: function () { return internals_1.LambdaInternals; } });