@remotion/serverless 4.0.244 → 4.0.245

package/dist/handlers/still.js

@@ -0,0 +1,334 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stillHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const no_react_1 = require("remotion/no-react");
+const version_1 = require("remotion/version");
+const cleanup_serialized_input_props_1 = require("../cleanup-serialized-input-props");
+const compress_props_1 = require("../compress-props");
+const constants_1 = require("../constants");
+const expected_out_name_1 = require("../expected-out-name");
+const format_costs_info_1 = require("../format-costs-info");
+const get_or_create_bucket_1 = require("../get-or-create-bucket");
+const on_downloads_helpers_1 = require("../on-downloads-helpers");
+const overall_render_progress_1 = require("../overall-render-progress");
+const validate_composition_1 = require("../validate-composition");
+const validate_download_behavior_1 = require("../validate-download-behavior");
+const validate_outname_1 = require("../validate-outname");
+const validate_privacy_1 = require("../validate-privacy");
+const write_lambda_error_1 = require("../write-lambda-error");
+const innerStillHandler = async ({ params: lambdaParams, expectedBucketOwner, renderId, onStream, timeoutInMilliseconds, providerSpecifics, }, cleanup) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (lambdaParams.type !== constants_1.ServerlessRoutines.still) {
+        throw new TypeError('Expected still type');
+    }
+    if (lambdaParams.version !== version_1.VERSION) {
+        if (!lambdaParams.version) {
+            throw new Error(`Version mismatch: When calling renderStillOnLambda(), you called the function ${process.env.AWS_LAMBDA_FUNCTION_NAME} which has the version ${version_1.VERSION} but the @remotion/lambda package is an older version. Deploy a new function and use it to call renderStillOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
+        }
+        throw new Error(`Version mismatch: When calling renderStillOnLambda(), you passed ${process.env.AWS_LAMBDA_FUNCTION_NAME} as the function, which has the version ${version_1.VERSION}, but the @remotion/lambda package you used to invoke the function has version ${lambdaParams.version}. Deploy a new function and use it to call renderStillOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
+    }
+    (0, validate_download_behavior_1.validateDownloadBehavior)(lambdaParams.downloadBehavior);
+    (0, validate_privacy_1.validatePrivacy)(lambdaParams.privacy, true);
+    (0, validate_outname_1.validateOutname)({
+        outName: lambdaParams.outName,
+        codec: null,
+        audioCodecSetting: null,
+        separateAudioTo: null,
+    });
+    const start = Date.now();
+    const browserInstancePromise = providerSpecifics.getBrowserInstance({
+        logLevel: lambdaParams.logLevel,
+        indent: false,
+        chromiumOptions: lambdaParams.chromiumOptions,
+        providerSpecifics,
+    });
+    const bucketNamePromise = (_a = lambdaParams.bucketName) !== null && _a !== void 0 ? _a : (0, get_or_create_bucket_1.internalGetOrCreateBucket)({
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        enableFolderExpiry: null,
+        customCredentials: null,
+        providerSpecifics,
+        forcePathStyle: lambdaParams.forcePathStyle,
+        skipPutAcl: false,
+    }).then((b) => b.bucketName);
+    const outputDir = renderer_1.RenderInternals.tmpDir('remotion-render-');
+    const outputPath = node_path_1.default.join(outputDir, 'output');
+    const region = providerSpecifics.getCurrentRegionInFunction();
+    const bucketName = await bucketNamePromise;
+    const serializedInputPropsWithCustomSchema = await (0, compress_props_1.decompressInputProps)({
+        bucketName,
+        expectedBucketOwner,
+        region,
+        serialized: lambdaParams.inputProps,
+        propsType: 'input-props',
+        providerSpecifics,
+        forcePathStyle: lambdaParams.forcePathStyle,
+    });
+    const serveUrl = providerSpecifics.convertToServeUrl({
+        urlOrId: lambdaParams.serveUrl,
+        region,
+        bucketName,
+    });
+    const { server, cleanupServer } = await renderer_1.RenderInternals.makeOrReuseServer(undefined, {
+        concurrency: 1,
+        indent: false,
+        port: null,
+        remotionRoot: process.cwd(),
+        logLevel: lambdaParams.logLevel,
+        webpackConfigOrServeUrl: serveUrl,
+        offthreadVideoCacheSizeInBytes: lambdaParams.offthreadVideoCacheSizeInBytes,
+        binariesDirectory: null,
+        forceIPv4: false,
+    }, {
+        onDownload: () => undefined,
+    });
+    cleanup.push(() => cleanupServer(true));
+    const browserInstance = await browserInstancePromise;
+    const composition = await (0, validate_composition_1.validateComposition)({
+        serveUrl,
+        browserInstance: browserInstance.instance,
+        composition: lambdaParams.composition,
+        serializedInputPropsWithCustomSchema,
+        envVariables: (_b = lambdaParams.envVariables) !== null && _b !== void 0 ? _b : {},
+        chromiumOptions: lambdaParams.chromiumOptions,
+        timeoutInMilliseconds: lambdaParams.timeoutInMilliseconds,
+        port: null,
+        forceHeight: lambdaParams.forceHeight,
+        forceWidth: lambdaParams.forceWidth,
+        logLevel: lambdaParams.logLevel,
+        server,
+        offthreadVideoCacheSizeInBytes: lambdaParams.offthreadVideoCacheSizeInBytes,
+        onBrowserDownload: () => {
+            throw new Error('Should not download a browser in Lambda');
+        },
+        onServeUrlVisited: () => undefined,
+        providerSpecifics,
+    });
+    const renderMetadata = {
+        startedDate: Date.now(),
+        codec: null,
+        compositionId: lambdaParams.composition,
+        estimatedTotalLambdaInvokations: 1,
+        estimatedRenderLambdaInvokations: 1,
+        siteId: serveUrl,
+        totalChunks: 1,
+        type: 'still',
+        imageFormat: lambdaParams.imageFormat,
+        inputProps: lambdaParams.inputProps,
+        lambdaVersion: version_1.VERSION,
+        framesPerLambda: 1,
+        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        renderId,
+        outName: (_c = lambdaParams.outName) !== null && _c !== void 0 ? _c : undefined,
+        privacy: lambdaParams.privacy,
+        audioCodec: null,
+        deleteAfter: lambdaParams.deleteAfter,
+        numberOfGifLoops: null,
+        downloadBehavior: lambdaParams.downloadBehavior,
+        audioBitrate: null,
+        metadata: null,
+        functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+        dimensions: {
+            height: composition.height * ((_d = lambdaParams.scale) !== null && _d !== void 0 ? _d : 1),
+            width: composition.width * ((_e = lambdaParams.scale) !== null && _e !== void 0 ? _e : 1),
+        },
+    };
+    const still = (0, overall_render_progress_1.makeInitialOverallRenderProgress)(timeoutInMilliseconds);
+    still.renderMetadata = renderMetadata;
+    await providerSpecifics.writeFile({
+        bucketName,
+        key: (0, constants_1.overallProgressKey)(renderId),
+        body: JSON.stringify(still),
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        privacy: 'private',
+        expectedBucketOwner,
+        downloadBehavior: null,
+        customCredentials: null,
+        forcePathStyle: lambdaParams.forcePathStyle,
+    });
+    const onBrowserDownload = () => {
+        throw new Error('Should not download a browser in Lambda');
+    };
+    const receivedArtifact = [];
+    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, bucketName, (0, expected_out_name_1.getCredentialsFromOutName)(lambdaParams.outName));
+    const onArtifact = (artifact) => {
+        if (receivedArtifact.find((a) => a.filename === artifact.filename)) {
+            return { alreadyExisted: true };
+        }
+        const storageKey = (0, constants_1.artifactName)(renderMetadata.renderId, artifact.filename);
+        receivedArtifact.push(providerSpecifics.makeArtifactWithDetails({
+            storageKey,
+            artifact,
+            region,
+            renderBucketName,
+        }));
+        const startTime = Date.now();
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel: lambdaParams.logLevel }, 'Writing artifact ' + artifact.filename + ' to S3');
+        providerSpecifics
+            .writeFile({
+            bucketName: renderBucketName,
+            key: storageKey,
+            body: artifact.content,
+            region,
+            privacy: lambdaParams.privacy,
+            expectedBucketOwner,
+            downloadBehavior: lambdaParams.downloadBehavior,
+            customCredentials,
+            forcePathStyle: lambdaParams.forcePathStyle,
+        })
+            .then(() => {
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: lambdaParams.logLevel }, `Wrote artifact to S3 in ${Date.now() - startTime}ms`);
+        })
+            .catch((err) => {
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: lambdaParams.logLevel }, 'Failed to write artifact to S3', err);
+        });
+        return { alreadyExisted: false };
+    };
+    await renderer_1.RenderInternals.internalRenderStill({
+        composition,
+        output: outputPath,
+        serveUrl,
+        envVariables: (_f = lambdaParams.envVariables) !== null && _f !== void 0 ? _f : {},
+        frame: renderer_1.RenderInternals.convertToPositiveFrameIndex({
+            frame: lambdaParams.frame,
+            durationInFrames: composition.durationInFrames,
+        }),
+        imageFormat: lambdaParams.imageFormat,
+        serializedInputPropsWithCustomSchema,
+        overwrite: false,
+        puppeteerInstance: browserInstance.instance,
+        jpegQuality: (_g = lambdaParams.jpegQuality) !== null && _g !== void 0 ? _g : renderer_1.RenderInternals.DEFAULT_JPEG_QUALITY,
+        chromiumOptions: lambdaParams.chromiumOptions,
+        scale: lambdaParams.scale,
+        timeoutInMilliseconds: lambdaParams.timeoutInMilliseconds,
+        browserExecutable: providerSpecifics.getChromiumPath(),
+        cancelSignal: null,
+        indent: false,
+        onBrowserLog: null,
+        onDownload: (0, on_downloads_helpers_1.onDownloadsHelper)(lambdaParams.logLevel),
+        port: null,
+        server,
+        logLevel: lambdaParams.logLevel,
+        serializedResolvedPropsWithCustomSchema: no_react_1.NoReactInternals.serializeJSONWithDate({
+            indent: undefined,
+            staticBase: null,
+            data: composition.props,
+        }).serializedString,
+        offthreadVideoCacheSizeInBytes: lambdaParams.offthreadVideoCacheSizeInBytes,
+        binariesDirectory: null,
+        onBrowserDownload,
+        onArtifact,
+    });
+    const { size } = await node_fs_1.default.promises.stat(outputPath);
+    await providerSpecifics.writeFile({
+        bucketName: renderBucketName,
+        key,
+        privacy: lambdaParams.privacy,
+        body: node_fs_1.default.createReadStream(outputPath),
+        expectedBucketOwner,
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        downloadBehavior: lambdaParams.downloadBehavior,
+        customCredentials,
+        forcePathStyle: lambdaParams.forcePathStyle,
+    });
+    await Promise.all([
+        node_fs_1.default.promises.rm(outputPath, { recursive: true }),
+        (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            serialized: lambdaParams.inputProps,
+            providerSpecifics,
+            forcePathStyle: lambdaParams.forcePathStyle,
+        }),
+        server.closeServer(true),
+    ]);
+    const estimatedPrice = providerSpecifics.estimatePrice({
+        durationInMilliseconds: Date.now() - start + 100,
+        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        lambdasInvoked: 1,
+        diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+    });
+    const { key: outKey, url } = providerSpecifics.getOutputUrl({
+        renderMetadata,
+        bucketName,
+        customCredentials,
+        currentRegion: providerSpecifics.getCurrentRegionInFunction(),
+    });
+    const payload = {
+        type: 'success',
+        output: url,
+        size,
+        sizeInBytes: size,
+        bucketName,
+        estimatedPrice: (0, format_costs_info_1.formatCostsInfo)(estimatedPrice),
+        renderId,
+        outKey,
+        receivedArtifacts: receivedArtifact,
+    };
+    onStream({
+        type: 'still-rendered',
+        payload,
+    });
+    await server.closeServer(true);
+};
+const stillHandler = async (options) => {
+    const { params } = options;
+    const cleanUpFn = [];
+    if (params.type !== constants_1.ServerlessRoutines.still) {
+        throw new Error('Params must be renderer');
+    }
+    try {
+        await innerStillHandler(options, cleanUpFn);
+        return { type: 'success' };
+    }
+    catch (err) {
+        // If this error is encountered, we can just retry as it
+        // is a very rare error to occur
+        const isBrowserError = options.providerSpecifics.isFlakyError(err);
+        const willRetry = isBrowserError || params.maxRetries > 0;
+        renderer_1.RenderInternals.Log.error({
+            indent: false,
+            logLevel: params.logLevel,
+        }, 'Got error:', err.stack, `Will retry = ${willRetry}`);
+        if (params.streamed) {
+            await options.onStream({
+                type: 'error-occurred',
+                payload: {
+                    error: err.stack,
+                    shouldRetry: willRetry,
+                    errorInfo: {
+                        name: err.name,
+                        message: err.message,
+                        stack: err.stack,
+                        chunk: null,
+                        frame: params.frame,
+                        type: 'renderer',
+                        isFatal: false,
+                        tmpDir: (0, write_lambda_error_1.getTmpDirStateIfENoSp)(err.stack, options.providerSpecifics),
+                        attempt: params.attempt,
+                        totalAttempts: 1 + params.maxRetries,
+                        willRetry,
+                    },
+                },
+            });
+        }
+        return {
+            type: 'error',
+            message: err.message,
+            stack: err.stack,
+        };
+    }
+    finally {
+        options.providerSpecifics.forgetBrowserEventLoop(options.params.type === constants_1.ServerlessRoutines.still
+            ? options.params.logLevel
+            : 'error');
+        cleanUpFn.forEach((c) => c());
+    }
+};
+exports.stillHandler = stillHandler;

package/dist/inspect-error.d.ts

@@ -0,0 +1,4 @@
+import type { EnhancedErrorInfo, LambdaErrorInfo } from './write-lambda-error';
+export declare const inspectErrors: ({ errors, }: {
+    errors: LambdaErrorInfo[];
+}) => 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,39 @@
+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-lambda-error';
+export declare function calculateSignature(payload: string, secret: string | null): string;
+type DynamicWebhookPayload = {
+    type: 'error';
+    errors: {
+        message: string;
+        name: string;
+        stack: string;
+    }[];
+} | {
+    type: 'success';
+    lambdaErrors: EnhancedErrorInfo[];
+    outputUrl: string | undefined;
+    outputFile: string | undefined;
+    timeToFinish: number | undefined;
+    costs: AfterRenderCost;
+} | {
+    type: 'timeout';
+};
+export type WebhookPayload = {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+    customData: Record<string, unknown> | null;
+} & DynamicWebhookPayload;
+export type WebhookClient = (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, {
+            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/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-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-lambda-error';
+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;