@remotion/serverless 4.0.244 → 4.0.246

package/dist/inner-routine.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.innerRoutine = exports.innerHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const client_1 = require("./client");
+const constants_1 = require("./constants");
+const compositions_1 = require("./handlers/compositions");
+const launch_1 = require("./handlers/launch");
+const progress_1 = require("./handlers/progress");
+const renderer_2 = require("./handlers/renderer");
+const start_1 = require("./handlers/start");
+const still_1 = require("./handlers/still");
+const info_1 = require("./info");
+const is_warm_1 = require("./is-warm");
+const leak_detection_1 = require("./leak-detection");
+const print_logging_grep_helper_1 = require("./print-logging-grep-helper");
+const innerHandler = async ({ params, responseWriter, context, providerSpecifics, insideFunctionSpecifics, webhookClient, }) => {
+    (0, leak_detection_1.setCurrentRequestId)(context.awsRequestId);
+    process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
+    const timeoutInMilliseconds = context.getRemainingTimeInMillis();
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'AWS Request ID:', context.awsRequestId);
+    (0, leak_detection_1.stopLeakDetection)();
+    if (!(context === null || context === void 0 ? void 0 : context.invokedFunctionArn)) {
+        throw new Error('Lambda function unexpectedly does not have context.invokedFunctionArn');
+    }
+    await insideFunctionSpecifics.deleteTmpDir();
+    const isWarm = (0, is_warm_1.getWarm)();
+    (0, is_warm_1.setWarm)();
+    const currentUserId = context.invokedFunctionArn.split(':')[4];
+    if (params.type === constants_1.ServerlessRoutines.still) {
+        providerSpecifics.validateDeleteAfter(params.deleteAfter);
+        const renderId = insideFunctionSpecifics.generateRandomId({
+            deleteAfter: params.deleteAfter,
+            randomHashFn: providerSpecifics.randomHash,
+        });
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.still, {
+                renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        try {
+            await new Promise((resolve, reject) => {
+                const onStream = async (payload) => {
+                    if (!params.streamed) {
+                        if (payload.type !== 'still-rendered') {
+                            throw new Error('Expected still-rendered');
+                        }
+                        await responseWriter.write(Buffer.from(JSON.stringify(payload.payload)));
+                        return;
+                    }
+                    const message = (0, client_1.makeStreamPayload)({
+                        message: payload,
+                    });
+                    return new Promise((innerResolve, innerReject) => {
+                        responseWriter
+                            .write(message)
+                            .then(() => {
+                            innerResolve();
+                        })
+                            .catch((err) => {
+                            reject(err);
+                            innerReject(err);
+                        });
+                    });
+                };
+                if (params.streamed) {
+                    onStream({
+                        type: 'render-id-determined',
+                        payload: { renderId },
+                    });
+                }
+                (0, still_1.stillHandler)({
+                    expectedBucketOwner: currentUserId,
+                    params,
+                    renderId,
+                    onStream,
+                    timeoutInMilliseconds,
+                    providerSpecifics,
+                    insideFunctionSpecifics,
+                })
+                    .then((r) => {
+                    resolve(r);
+                })
+                    .catch((err) => {
+                    reject(err);
+                });
+            });
+            await responseWriter.end();
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.log({ err });
+        }
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.start) {
+        const renderId = insideFunctionSpecifics.generateRandomId({
+            deleteAfter: params.deleteAfter,
+            randomHashFn: providerSpecifics.randomHash,
+        });
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.start, {
+                renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, start_1.startHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+                timeoutInMilliseconds,
+                renderId,
+            },
+            providerSpecifics,
+            insideFunctionSpecifics,
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.launch) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.launch, {
+                renderId: params.renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, launch_1.launchHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+                getRemainingTimeInMillis: context.getRemainingTimeInMillis,
+            },
+            providerSpecifics,
+            client: webhookClient,
+            insideFunctionSpecifics,
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.status) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.status, {
+                renderId: params.renderId,
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, progress_1.progressHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+                timeoutInMilliseconds,
+                retriesRemaining: 2,
+                providerSpecifics,
+                insideFunctionSpecifics,
+            },
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.renderer) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.renderer, {
+                renderId: params.renderId,
+                chunk: String(params.chunk),
+                dumpLogs: String(renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose')),
+                resolvedProps: JSON.stringify(params.resolvedProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        await new Promise((resolve, reject) => {
+            (0, renderer_2.rendererHandler)({
+                params,
+                options: {
+                    expectedBucketOwner: currentUserId,
+                    isWarm,
+                },
+                onStream: (payload) => {
+                    const message = (0, client_1.makeStreamPayload)({
+                        message: payload,
+                    });
+                    const writeProm = responseWriter.write(message);
+                    return new Promise((innerResolve, innerReject) => {
+                        writeProm
+                            .then(() => {
+                            innerResolve();
+                        })
+                            .catch((err) => {
+                            reject(err);
+                            innerReject(err);
+                        });
+                    });
+                },
+                requestContext: context,
+                providerSpecifics,
+                insideFunctionSpecifics,
+            })
+                .then((res) => {
+                resolve(res);
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.info) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.info, {
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, info_1.infoHandler)(params);
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.compositions) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.compositions, {
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, compositions_1.compositionsHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+            },
+            providerSpecifics,
+            insideFunctionSpecifics,
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    throw new Error(constants_1.COMMAND_NOT_FOUND);
+};
+exports.innerHandler = innerHandler;
+const innerRoutine = async ({ params, responseWriter, context, providerSpecifics, insideFunctionSpecifics, webhookClient, }) => {
+    try {
+        await (0, exports.innerHandler)({
+            params,
+            responseWriter,
+            context,
+            providerSpecifics,
+            insideFunctionSpecifics,
+            webhookClient,
+        });
+    }
+    catch (err) {
+        const res = {
+            type: 'error',
+            message: err.message,
+            stack: err.stack,
+        };
+        await responseWriter.write(Buffer.from(JSON.stringify(res)));
+        await responseWriter.end();
+    }
+};
+exports.innerRoutine = innerRoutine;

package/dist/inspect-error.d.ts

@@ -0,0 +1,4 @@
+import type { EnhancedErrorInfo, FunctionErrorInfo } from './write-error-to-storage';
+export declare const inspectErrors: ({ errors, }: {
+    errors: FunctionErrorInfo[];
+}) => EnhancedErrorInfo[];

package/dist/inspect-error.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectErrors = void 0;
+const docs_url_1 = require("./docs-url");
+const error_category_1 = require("./error-category");
+const FAILED_TO_LAUNCH_TOKEN = 'Failed to launch browser.';
+const getExplanation = (stack) => {
+    if (stack.includes('FATAL:zygote_communication_linux.cc')) {
+        return (FAILED_TO_LAUNCH_TOKEN +
+            ' Will be retried - you can probably ignore this error.');
+    }
+    if (stack.includes('error while loading shared libraries: libnss3.so')) {
+        return (FAILED_TO_LAUNCH_TOKEN +
+            ' Will be retried - you can probably ignore this error.');
+    }
+    if (stack.includes('TooManyRequestsException')) {
+        return `AWS returned an "TooManyRequestsException" error message which could mean you reached the concurrency limit of AWS Lambda. You can increase the limit - read this troubleshooting page: ${docs_url_1.DOCS_URL}/docs/lambda/troubleshooting/rate-limit`;
+    }
+    if ((0, error_category_1.errorIsOutOfSpaceError)(stack)) {
+        return `Your lambda function reached the storage limit. Reduce the amount of space needed per lambda function or increase the storage limit: ${docs_url_1.DOCS_URL}/docs/lambda/disk-size.`;
+    }
+    if ((0, error_category_1.isErrInsufficientResourcesErr)(stack)) {
+        return 'The lambda ran out of memory. Deploy a new function with more memory.';
+    }
+    if ((0, error_category_1.isBrowserCrashedError)(stack)) {
+        return 'The browser crashed while rendering the video. Deploy a new function with memory to give the browser more resources.';
+    }
+    return null;
+};
+const inspectErrors = ({ errors, }) => {
+    return errors.map((e) => {
+        return {
+            ...e,
+            explanation: getExplanation(e.stack),
+            s3Location: '',
+        };
+    });
+};
+exports.inspectErrors = inspectErrors;

package/dist/invoke-webhook.d.ts

@@ -0,0 +1,42 @@
+import type { LogLevel } from '@remotion/renderer';
+import type https from 'https';
+import type http from 'node:http';
+import type { AfterRenderCost } from './constants';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
+export declare function calculateSignature(payload: string, secret: string | null): string;
+type StaticWebhookPayload = {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+    customData: Record<string, unknown> | null;
+};
+export type WebhookErrorPayload = StaticWebhookPayload & {
+    type: 'error';
+    errors: {
+        message: string;
+        name: string;
+        stack: string;
+    }[];
+};
+export type WebhookSuccessPayload = StaticWebhookPayload & {
+    type: 'success';
+    lambdaErrors: EnhancedErrorInfo[];
+    outputUrl: string | undefined;
+    outputFile: string | undefined;
+    timeToFinish: number | undefined;
+    costs: AfterRenderCost;
+};
+export type WebhookTimeoutPayload = StaticWebhookPayload & {
+    type: 'timeout';
+};
+export type WebhookPayload = WebhookErrorPayload | WebhookSuccessPayload | WebhookTimeoutPayload;
+export type WebhookClient = (url: string) => (url: string | URL, options: https.RequestOptions, callback?: (res: http.IncomingMessage) => void) => http.ClientRequest;
+type InvokeWebhookOptions = {
+    payload: WebhookPayload;
+    url: string;
+    secret: string | null;
+    redirectsSoFar: number;
+    client: WebhookClient;
+};
+export declare const invokeWebhook: (options: InvokeWebhookOptions, logLevel: LogLevel, retries?: number, errors?: number) => Promise<void>;
+export {};

package/dist/invoke-webhook.js

@@ -0,0 +1,116 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeWebhook = void 0;
+exports.calculateSignature = calculateSignature;
+const renderer_1 = require("@remotion/renderer");
+const Crypto = __importStar(require("node:crypto"));
+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;
+}
+// Don't handle 304 status code (Not Modified) as a redirect,
+// since the browser will display the right page.
+const redirectStatusCodes = [301, 302, 303, 307, 308];
+function invokeWebhookRaw({ payload, secret, url, redirectsSoFar, client, }) {
+    const jsonPayload = JSON.stringify(payload);
+    return new Promise((resolve, reject) => {
+        const req = client(url)(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': jsonPayload.length,
+                'X-Remotion-Mode': 'production',
+                'X-Remotion-Signature': calculateSignature(jsonPayload, secret),
+                'X-Remotion-Status': payload.type,
+            },
+            timeout: 5000,
+        }, (res) => {
+            if (res.statusCode && res.statusCode > 299) {
+                if (redirectStatusCodes.includes(res.statusCode)) {
+                    if (!res.headers.location) {
+                        reject(new Error(`Received a status code ${res.statusCode} but no "Location" header while calling ${res.headers.location}`));
+                        return;
+                    }
+                    if (redirectsSoFar > 10) {
+                        reject(new Error(`Too many redirects while downloading ${url}`));
+                        return;
+                    }
+                    invokeWebhookRaw({
+                        payload,
+                        secret,
+                        url: res.headers.location,
+                        redirectsSoFar: redirectsSoFar + 1,
+                        client,
+                    })
+                        .then(resolve)
+                        .catch(reject);
+                    return;
+                }
+                reject(new Error(`Sent a webhook to ${url} but got a status code of ${res.statusCode} with message '${res.statusMessage}'`));
+                return;
+            }
+            resolve();
+        });
+        req.write(jsonPayload, (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                req.end();
+            }
+        });
+        req.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+function exponentialBackoff(errorCount) {
+    return 1000 * 2 ** (errorCount - 1);
+}
+const invokeWebhook = async (options, logLevel, retries = 2, errors = 0) => {
+    try {
+        await invokeWebhookRaw(options);
+    }
+    catch (err) {
+        if (retries === 0) {
+            throw err;
+        }
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, 'Could not send webhook due to error:');
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, err.stack);
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Retrying in ${exponentialBackoff(errors)}ms.`);
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, exponentialBackoff(errors));
+        });
+        return (0, exports.invokeWebhook)(options, logLevel, retries - 1, errors + 1);
+    }
+};
+exports.invokeWebhook = invokeWebhook;

package/dist/is-warm.d.ts

@@ -0,0 +1,2 @@
+export declare const setWarm: () => void;
+export declare const getWarm: () => boolean;

package/dist/is-warm.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWarm = exports.setWarm = void 0;
+let warm = false;
+const setWarm = () => {
+    warm = true;
+};
+exports.setWarm = setWarm;
+const getWarm = () => warm;
+exports.getWarm = getWarm;

package/dist/leak-detection.d.ts

@@ -0,0 +1,4 @@
+import type { NodeIntrospection } from './why-is-node-running';
+export declare const stopLeakDetection: () => void;
+export declare const setCurrentRequestId: (awsRequestId: string) => void;
+export declare const startLeakDetection: (leakDetection: NodeIntrospection, awsRequestId: string) => void;

package/dist/leak-detection.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLeakDetection = exports.setCurrentRequestId = exports.stopLeakDetection = void 0;
+const why_is_node_running_1 = require("./why-is-node-running");
+let currentRequestId = null;
+let leakDetectionTimeout = null;
+const stopLeakDetection = () => {
+    if (leakDetectionTimeout !== null) {
+        clearTimeout(leakDetectionTimeout.timeout);
+        leakDetectionTimeout = null;
+    }
+};
+exports.stopLeakDetection = stopLeakDetection;
+const setCurrentRequestId = (awsRequestId) => {
+    currentRequestId = awsRequestId;
+};
+exports.setCurrentRequestId = setCurrentRequestId;
+const startLeakDetection = (leakDetection, awsRequestId) => {
+    currentRequestId = awsRequestId;
+    leakDetectionTimeout = {
+        awsRequestId,
+        timeout: setTimeout(() => {
+            // First allow request ID to be set
+            setTimeout(() => {
+                if (currentRequestId !== awsRequestId) {
+                    // New function, all good
+                    return;
+                }
+                console.log('Leak detected: Lambda function is still running 10s after the render has finished.');
+                console.log('You may report this to the Remotion team.');
+                console.log('Include the logs below:');
+                (0, why_is_node_running_1.whyIsNodeRunning)(leakDetection);
+                console.log('Force-quitting the Lambda function now.');
+                process.exit(0);
+            }, 100);
+        }, 10000),
+    };
+    leakDetectionTimeout.timeout.unref();
+};
+exports.startLeakDetection = startLeakDetection;

package/dist/make-bucket-name.d.ts

@@ -1,3 +1,3 @@
 import type { ProviderSpecifics } from './provider-implementation';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 export declare const makeBucketName: <Provider extends CloudProvider>(region: Provider["region"], providerSpecifics: ProviderSpecifics<Provider>) => string;

package/dist/make-timeout-error.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
+export declare const makeTimeoutError: <Provider extends CloudProvider>({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, providerSpecifics, }: {
+    timeoutInMilliseconds: number;
+    renderMetadata: RenderMetadata<Provider>;
+    renderId: string;
+    missingChunks: number[];
+    functionName: string;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => EnhancedErrorInfo;

package/dist/make-timeout-error.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTimeoutError = void 0;
+const make_timeout_message_1 = require("./make-timeout-message");
+const makeTimeoutError = ({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, providerSpecifics, }) => {
+    const message = (0, make_timeout_message_1.makeTimeoutMessage)({
+        missingChunks,
+        renderMetadata,
+        timeoutInMilliseconds,
+        renderId,
+        functionName,
+        region,
+        providerSpecifics,
+    });
+    const error = new Error(message);
+    return {
+        attempt: 1,
+        chunk: null,
+        explanation: null,
+        frame: null,
+        isFatal: true,
+        s3Location: '',
+        stack: error.stack,
+        tmpDir: null,
+        totalAttempts: 1,
+        type: 'stitcher',
+        willRetry: false,
+        message,
+        name: 'TimeoutError',
+    };
+};
+exports.makeTimeoutError = makeTimeoutError;

package/dist/make-timeout-message.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+export declare const makeTimeoutMessage: <Provider extends CloudProvider>({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, providerSpecifics, }: {
+    timeoutInMilliseconds: number;
+    missingChunks: number[];
+    renderMetadata: RenderMetadata<Provider>;
+    renderId: string;
+    region: Provider["region"];
+    functionName: string;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => string;

package/dist/make-timeout-message.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTimeoutMessage = void 0;
+const constants_1 = require("./constants");
+const docs_url_1 = require("./docs-url");
+const MAX_MISSING_CHUNKS = 5;
+const makeChunkMissingMessage = ({ missingChunks, renderMetadata, region, providerSpecifics, functionName, }) => {
+    if (missingChunks.length === 0) {
+        return 'All chunks have been successfully rendered, but the main function has timed out.';
+    }
+    return [
+        `The following chunks are missing (showing ${Math.min(MAX_MISSING_CHUNKS, missingChunks.length)} out of ${missingChunks.length}):`,
+        ...missingChunks
+            .map((ch) => {
+            const isLastChunk = ch === renderMetadata.totalChunks - 1;
+            const start = ch * renderMetadata.framesPerLambda;
+            const end = renderMetadata.type === 'still'
+                ? 0
+                : isLastChunk
+                    ? renderMetadata.frameRange[1]
+                    : (ch + 1) * renderMetadata.framesPerLambda - 1;
+            const msg = `Chunk ${ch} (Frames ${start} - ${end})`;
+            return [
+                msg,
+                `▸ Logs for chunk ${ch}: ${providerSpecifics.getLoggingUrlForRendererFunction({
+                    functionName,
+                    region,
+                    rendererFunctionName: null,
+                    renderId: renderMetadata.renderId,
+                    chunk: ch,
+                })}`,
+            ].join('\n');
+        })
+            .slice(0, 5),
+    ].join('\n');
+};
+const makeTimeoutMessage = ({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, providerSpecifics, }) => {
+    const cloudWatchRendererUrl = providerSpecifics.getLoggingUrlForRendererFunction({
+        renderId,
+        functionName,
+        region,
+        rendererFunctionName: functionName,
+        chunk: null,
+    });
+    const cloudWatchLaunchUrl = providerSpecifics.getLoggingUrlForMethod({
+        renderId,
+        functionName,
+        method: constants_1.ServerlessRoutines.launch,
+        region,
+        rendererFunctionName: functionName,
+    });
+    const message = [
+        `The main function timed out after ${timeoutInMilliseconds}ms.`,
+        makeChunkMissingMessage({
+            missingChunks,
+            renderMetadata,
+            region,
+            providerSpecifics,
+            functionName,
+        }),
+        '',
+        `Consider increasing the timeout of your function.`,
+        `▸ You can use the "--timeout" parameter when deploying a function via CLI, or the "timeoutInSeconds" parameter when using the deployFunction() API.`,
+        `${docs_url_1.DOCS_URL}/docs/lambda/cli/functions#deploy`,
+        '',
+        '▸ Visit the logs for the main function:',
+        cloudWatchLaunchUrl,
+        '▸ Visit the logs for the renderer functions:',
+        cloudWatchRendererUrl,
+        '',
+        '▸ Get help on debugging this error:',
+        `${docs_url_1.DOCS_URL}/docs/lambda/troubleshooting/debug`,
+    ].join('\n');
+    return message;
+};
+exports.makeTimeoutMessage = makeTimeoutMessage;