@remotion/serverless 4.0.244 → 4.0.246

package/dist/handlers/launch.js

@@ -0,0 +1,600 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const version_1 = require("remotion/version");
+const compress_props_1 = require("../compress-props");
+const constants_1 = require("../constants");
+const docs_url_1 = require("../docs-url");
+const expected_out_name_1 = require("../expected-out-name");
+const invoke_webhook_1 = require("../invoke-webhook");
+const overall_render_progress_1 = require("../overall-render-progress");
+const best_frames_per_function_param_1 = require("../best-frames-per-function-param");
+const cleanup_props_1 = require("../cleanup-props");
+const find_output_file_in_bucket_1 = require("../find-output-file-in-bucket");
+const merge_chunks_1 = require("../merge-chunks");
+const plan_frame_ranges_1 = require("../plan-frame-ranges");
+const stream_renderer_1 = require("../stream-renderer");
+const validate_composition_1 = require("../validate-composition");
+const validate_frames_per_function_1 = require("../validate-frames-per-function");
+const validate_outname_1 = require("../validate-outname");
+const validate_privacy_1 = require("../validate-privacy");
+const write_error_to_storage_1 = require("../write-error-to-storage");
+const innerLaunchHandler = async ({ functionName, params, options, overallProgress, registerCleanupTask, providerSpecifics, insideFunctionSpecifics, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (params.type !== constants_1.ServerlessRoutines.launch) {
+        throw new Error('Expected launch type');
+    }
+    const startedDate = Date.now();
+    const browserInstance = insideFunctionSpecifics.getBrowserInstance({
+        logLevel: params.logLevel,
+        indent: false,
+        chromiumOptions: params.chromiumOptions,
+        providerSpecifics,
+        insideFunctionSpecifics,
+    });
+    const inputPropsPromise = (0, compress_props_1.decompressInputProps)({
+        bucketName: params.bucketName,
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        serialized: params.inputProps,
+        propsType: 'input-props',
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+    });
+    const logOptions = {
+        indent: false,
+        logLevel: params.logLevel,
+    };
+    const serializedInputPropsWithCustomSchema = await inputPropsPromise;
+    renderer_1.RenderInternals.Log.info(logOptions, 'Waiting for browser to be ready:', serializedInputPropsWithCustomSchema);
+    const { instance } = await browserInstance;
+    renderer_1.RenderInternals.Log.info(logOptions, 'Validating composition, input props:', serializedInputPropsWithCustomSchema);
+    const startTime = Date.now();
+    const comp = await (0, validate_composition_1.validateComposition)({
+        serveUrl: params.serveUrl,
+        composition: params.composition,
+        browserInstance: instance,
+        serializedInputPropsWithCustomSchema,
+        envVariables: (_a = params.envVariables) !== null && _a !== void 0 ? _a : {},
+        timeoutInMilliseconds: params.timeoutInMilliseconds,
+        chromiumOptions: params.chromiumOptions,
+        port: null,
+        forceHeight: params.forceHeight,
+        forceWidth: params.forceWidth,
+        logLevel: params.logLevel,
+        server: undefined,
+        offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+        onBrowserDownload: () => {
+            throw new Error('Should not download a browser in a function');
+        },
+        onServeUrlVisited: () => {
+            overallProgress.setServeUrlOpened(Date.now());
+        },
+        providerSpecifics,
+    });
+    overallProgress.setCompositionValidated(Date.now());
+    renderer_1.RenderInternals.Log.info(logOptions, 'Composition validated, resolved props', comp.props);
+    renderer_1.RenderInternals.validateBitrate(params.audioBitrate, 'audioBitrate');
+    renderer_1.RenderInternals.validateBitrate(params.videoBitrate, 'videoBitrate');
+    renderer_1.RenderInternals.validateConcurrency({
+        value: params.concurrencyPerFunction,
+        setting: 'concurrencyPerLambda',
+        checkIfValidForCurrentMachine: ((_b = params.rendererFunctionName) !== null && _b !== void 0 ? _b : null) === null,
+    });
+    const realFrameRange = renderer_1.RenderInternals.getRealFrameRange(comp.durationInFrames, params.frameRange);
+    const frameCount = renderer_1.RenderInternals.getFramesToRender(realFrameRange, params.everyNthFrame);
+    const framesPerLambda = (_c = params.framesPerFunction) !== null && _c !== void 0 ? _c : (0, best_frames_per_function_param_1.bestFramesPerFunctionParam)(frameCount.length);
+    (0, validate_frames_per_function_1.validateFramesPerFunction)({
+        framesPerFunction: framesPerLambda,
+        durationInFrames: frameCount.length,
+    });
+    (0, validate_outname_1.validateOutname)({
+        outName: params.outName,
+        codec: params.codec,
+        audioCodecSetting: params.audioCodec,
+        separateAudioTo: null,
+    });
+    (0, validate_privacy_1.validatePrivacy)(params.privacy, true);
+    renderer_1.RenderInternals.validatePuppeteerTimeout(params.timeoutInMilliseconds);
+    const { chunks } = (0, plan_frame_ranges_1.planFrameRanges)({
+        framesPerFunction: framesPerLambda,
+        frameRange: realFrameRange,
+        everyNthFrame: params.everyNthFrame,
+    });
+    if (chunks.length > constants_1.MAX_FUNCTIONS_PER_RENDER) {
+        throw new Error(`Too many functions: This render would cause ${chunks.length} 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.length}, framesPerLambda=${framesPerLambda}. See ${docs_url_1.DOCS_URL}/docs/lambda/concurrency#too-many-functions for help.`);
+    }
+    overallProgress.setExpectedChunks(chunks.length);
+    const sortedChunks = chunks.slice().sort((a, b) => a[0] - b[0]);
+    const serializedResolved = (0, compress_props_1.serializeOrThrow)(comp.props, 'resolved-props');
+    const needsToUpload = (0, compress_props_1.getNeedsToUpload)({
+        type: 'video-or-audio',
+        sizes: [
+            serializedResolved.length,
+            params.inputProps.type === 'bucket-url'
+                ? params.inputProps.hash.length
+                : params.inputProps.payload.length,
+            JSON.stringify(params.envVariables).length,
+        ],
+        providerSpecifics,
+    });
+    const serializedResolvedProps = await (0, compress_props_1.compressInputProps)({
+        propsType: 'resolved-props',
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        stringifiedInputProps: serializedResolved,
+        userSpecifiedBucketName: params.bucketName,
+        needsToUpload,
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+        skipPutAcl: false,
+    });
+    registerCleanupTask(() => {
+        return (0, cleanup_props_1.cleanupProps)({
+            serializedResolvedProps,
+            inputProps: params.inputProps,
+            providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+        });
+    });
+    const fps = comp.fps / params.everyNthFrame;
+    // If for 150 functions, we stream every frame, we DDos ourselves.
+    // Throttling a bit, allowing more progress if there is lower concurrency.
+    const progressEveryNthFrame = Math.ceil(chunks.length / 15);
+    const lambdaPayloads = chunks.map((chunkPayload) => {
+        var _a;
+        const payload = {
+            type: constants_1.ServerlessRoutines.renderer,
+            frameRange: chunkPayload,
+            serveUrl: params.serveUrl,
+            chunk: sortedChunks.indexOf(chunkPayload),
+            composition: params.composition,
+            fps: comp.fps,
+            height: comp.height,
+            width: comp.width,
+            durationInFrames: comp.durationInFrames,
+            bucketName: params.bucketName,
+            retriesLeft: params.maxRetries,
+            inputProps: params.inputProps,
+            renderId: params.renderId,
+            imageFormat: params.imageFormat,
+            codec: params.codec,
+            crf: params.crf,
+            envVariables: params.envVariables,
+            pixelFormat: params.pixelFormat,
+            proResProfile: params.proResProfile,
+            x264Preset: params.x264Preset,
+            jpegQuality: params.jpegQuality,
+            privacy: params.privacy,
+            logLevel: (_a = params.logLevel) !== null && _a !== void 0 ? _a : 'info',
+            attempt: 1,
+            timeoutInMilliseconds: params.timeoutInMilliseconds,
+            chromiumOptions: params.chromiumOptions,
+            scale: params.scale,
+            everyNthFrame: params.everyNthFrame,
+            concurrencyPerLambda: params.concurrencyPerFunction,
+            muted: params.muted,
+            audioBitrate: params.audioBitrate,
+            videoBitrate: params.videoBitrate,
+            encodingMaxRate: params.encodingMaxRate,
+            encodingBufferSize: params.encodingBufferSize,
+            launchFunctionConfig: {
+                version: version_1.VERSION,
+            },
+            resolvedProps: serializedResolvedProps,
+            offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+            deleteAfter: params.deleteAfter,
+            colorSpace: params.colorSpace,
+            preferLossless: params.preferLossless,
+            compositionStart: realFrameRange[0],
+            framesPerLambda,
+            progressEveryNthFrame,
+            forcePathStyle: params.forcePathStyle,
+            metadata: params.metadata,
+        };
+        return payload;
+    });
+    renderer_1.RenderInternals.Log.info(logOptions, 'Render plan: ', chunks.map((c, i) => `Chunk ${i} (Frames ${c[0]} - ${c[1]})`).join(', '));
+    const renderMetadata = {
+        startedDate,
+        totalChunks: chunks.length,
+        estimatedTotalLambdaInvokations: [
+            // Direct invokations
+            chunks.length,
+            // This function
+            1,
+        ].reduce((a, b) => a + b, 0),
+        estimatedRenderLambdaInvokations: chunks.length,
+        compositionId: comp.id,
+        siteId: params.serveUrl,
+        codec: params.codec,
+        type: 'video',
+        imageFormat: params.imageFormat,
+        inputProps: params.inputProps,
+        lambdaVersion: version_1.VERSION,
+        framesPerLambda,
+        memorySizeInMb: insideFunctionSpecifics.getCurrentMemorySizeInMb(),
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        renderId: params.renderId,
+        outName: (_d = params.outName) !== null && _d !== void 0 ? _d : undefined,
+        privacy: params.privacy,
+        everyNthFrame: params.everyNthFrame,
+        frameRange: realFrameRange,
+        audioCodec: params.audioCodec,
+        deleteAfter: params.deleteAfter,
+        numberOfGifLoops: params.numberOfGifLoops,
+        downloadBehavior: params.downloadBehavior,
+        audioBitrate: params.audioBitrate,
+        muted: params.muted,
+        metadata: params.metadata,
+        functionName: insideFunctionSpecifics.getCurrentFunctionName(),
+        dimensions: {
+            width: comp.width * ((_e = params.scale) !== null && _e !== void 0 ? _e : 1),
+            height: comp.height * ((_f = params.scale) !== null && _f !== void 0 ? _f : 1),
+        },
+    };
+    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
+        ? null
+        : ((_h = (_g = params.outName) === null || _g === void 0 ? void 0 : _g.s3OutputProvider) !== null && _h !== void 0 ? _h : null));
+    if (!params.overwrite) {
+        const findOutputFile = insideFunctionSpecifics.timer('Checking if output file already exists', params.logLevel);
+        const output = await (0, find_output_file_in_bucket_1.findOutputFileInBucket)({
+            bucketName: params.bucketName,
+            customCredentials,
+            renderMetadata,
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            currentRegion: providerSpecifics.getCurrentRegionInFunction(),
+            providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+        });
+        if (output) {
+            throw new TypeError(`Output file "${key}" in bucket "${renderBucketName}" in region "${providerSpecifics.getCurrentRegionInFunction()}" already exists. Delete it before re-rendering, or set the 'overwrite' option in renderMediaOnLambda() to overwrite it."`);
+        }
+        findOutputFile.end();
+    }
+    overallProgress.setRenderMetadata(renderMetadata);
+    const outdir = (0, path_1.join)(renderer_1.RenderInternals.tmpDir(constants_1.CONCAT_FOLDER_TOKEN), 'bucket');
+    if ((0, fs_1.existsSync)(outdir)) {
+        (0, fs_1.rmSync)(outdir, {
+            recursive: true,
+        });
+    }
+    (0, fs_1.mkdirSync)(outdir);
+    const files = [];
+    const onArtifact = (artifact) => {
+        if (overallProgress
+            .getReceivedArtifacts()
+            .find((a) => a.filename === artifact.filename)) {
+            return { alreadyExisted: true };
+        }
+        const region = providerSpecifics.getCurrentRegionInFunction();
+        const storageKey = (0, constants_1.artifactName)(renderMetadata.renderId, artifact.filename);
+        const start = Date.now();
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Writing artifact ' + artifact.filename + ' to S3');
+        providerSpecifics
+            .writeFile({
+            bucketName: renderBucketName,
+            key: storageKey,
+            body: artifact.content,
+            region,
+            privacy: params.privacy,
+            expectedBucketOwner: options.expectedBucketOwner,
+            downloadBehavior: params.downloadBehavior,
+            customCredentials,
+            forcePathStyle: params.forcePathStyle,
+        })
+            .then(() => {
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, `Wrote artifact to S3 in ${Date.now() - start}ms`);
+            overallProgress.addReceivedArtifact(providerSpecifics.makeArtifactWithDetails({
+                region,
+                renderBucketName,
+                storageKey,
+                artifact,
+            }));
+        })
+            .catch((err) => {
+            overallProgress.addErrorWithoutUpload({
+                type: 'artifact',
+                message: err.message,
+                name: err.name,
+                stack: err.stack,
+                tmpDir: null,
+                frame: artifact.frame,
+                chunk: null,
+                isFatal: false,
+                attempt: 1,
+                willRetry: false,
+                totalAttempts: 1,
+            });
+            overallProgress.upload();
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to write artifact to S3', err);
+        });
+        return { alreadyExisted: false };
+    };
+    await Promise.all(lambdaPayloads.map(async (payload) => {
+        await (0, stream_renderer_1.streamRendererFunctionWithRetry)({
+            files,
+            functionName,
+            outdir,
+            overallProgress,
+            payload,
+            logLevel: params.logLevel,
+            onArtifact,
+            providerSpecifics,
+        });
+    }));
+    const postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
+        bucketName: params.bucketName,
+        renderId: params.renderId,
+        expectedBucketOwner: options.expectedBucketOwner,
+        numberOfFrames: frameCount.length,
+        audioCodec: params.audioCodec,
+        chunkCount: chunks.length,
+        codec: params.codec,
+        customCredentials,
+        downloadBehavior: params.downloadBehavior,
+        fps,
+        key,
+        numberOfGifLoops: params.numberOfGifLoops,
+        privacy: params.privacy,
+        renderBucketName,
+        inputProps: params.inputProps,
+        serializedResolvedProps,
+        renderMetadata,
+        audioBitrate: params.audioBitrate,
+        logLevel: params.logLevel,
+        framesPerLambda,
+        binariesDirectory: null,
+        preferLossless: params.preferLossless,
+        compositionStart: realFrameRange[0],
+        outdir,
+        files: files.sort(),
+        overallProgress,
+        startTime,
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+        insideFunctionSpecifics,
+    });
+    return postRenderData;
+};
+const launchHandler = async ({ params, options, providerSpecifics, client, insideFunctionSpecifics, }) => {
+    var _a, _b, _c;
+    if (params.type !== constants_1.ServerlessRoutines.launch) {
+        throw new Error('Expected launch type');
+    }
+    const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : insideFunctionSpecifics.getCurrentFunctionName();
+    const logOptions = {
+        indent: false,
+        logLevel: params.logLevel,
+    };
+    const cleanupTasks = [];
+    const registerCleanupTask = (task) => {
+        cleanupTasks.push(task);
+    };
+    const runCleanupTasks = () => {
+        const prom = Promise.all(cleanupTasks)
+            .then(() => {
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Ran cleanup tasks');
+        })
+            .catch((err) => {
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to run cleanup tasks:', err);
+        });
+        cleanupTasks.length = 0;
+        return prom;
+    };
+    const onTimeout = async () => {
+        var _a;
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Function is about to time out. Can not finish render.');
+        // @ts-expect-error - We are adding a listener to a global variable
+        if (globalThis._dumpUnreleasedBuffers) {
+            // @ts-expect-error - We are adding a listener to a global variable
+            globalThis._dumpUnreleasedBuffers.emit('dump-unreleased-buffers');
+        }
+        runCleanupTasks();
+        if (!params.webhook) {
+            renderer_1.RenderInternals.Log.verbose({
+                indent: false,
+                logLevel: params.logLevel,
+            }, 'No webhook specified.');
+            return;
+        }
+        if (webhookInvoked) {
+            renderer_1.RenderInternals.Log.verbose({
+                indent: false,
+                logLevel: params.logLevel,
+            }, 'Webhook already invoked. Not invoking again.');
+            return;
+        }
+        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,
+                    customData: (_a = params.webhook.customData) !== null && _a !== void 0 ? _a : null,
+                },
+                redirectsSoFar: 0,
+                client,
+            }, params.logLevel);
+            renderer_1.RenderInternals.Log.verbose({
+                indent: false,
+                logLevel: params.logLevel,
+            }, 'Successfully invoked timeout webhook.', params.webhook.url);
+            webhookInvoked = true;
+        }
+        catch (err) {
+            if (process.env.NODE_ENV === 'test') {
+                throw err;
+            }
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to invoke webhook:');
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, err);
+            overallProgress.addErrorWithoutUpload({
+                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,
+            });
+            overallProgress.upload();
+        }
+    };
+    let webhookInvoked = false;
+    const webhookDueToTimeout = setTimeout(onTimeout, Math.max(options.getRemainingTimeInMillis() - 1000, 1000));
+    renderer_1.RenderInternals.Log.info(logOptions, `Function has ${Math.max(options.getRemainingTimeInMillis() - 1000, 1000)} before it times out`);
+    const overallProgress = (0, overall_render_progress_1.makeOverallRenderProgress)({
+        renderId: params.renderId,
+        bucketName: params.bucketName,
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        timeoutTimestamp: options.getRemainingTimeInMillis() + Date.now(),
+        logLevel: params.logLevel,
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+    });
+    try {
+        const postRenderData = await innerLaunchHandler({
+            functionName,
+            params,
+            options,
+            overallProgress,
+            registerCleanupTask,
+            providerSpecifics,
+            insideFunctionSpecifics,
+        });
+        clearTimeout(webhookDueToTimeout);
+        if (!params.webhook || webhookInvoked) {
+            return {
+                type: 'success',
+            };
+        }
+        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,
+                    customData: (_b = params.webhook.customData) !== null && _b !== void 0 ? _b : null,
+                    outputUrl: postRenderData.outputFile,
+                    lambdaErrors: postRenderData.errors,
+                    outputFile: postRenderData.outputFile,
+                    timeToFinish: postRenderData.timeToFinish,
+                    costs: postRenderData.cost,
+                },
+                redirectsSoFar: 0,
+                client,
+            }, params.logLevel);
+            webhookInvoked = true;
+        }
+        catch (err) {
+            if (process.env.NODE_ENV === 'test') {
+                throw err;
+            }
+            overallProgress.addErrorWithoutUpload({
+                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,
+            });
+            overallProgress.upload();
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to invoke webhook:');
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, err);
+        }
+        runCleanupTasks();
+        return {
+            type: 'success',
+        };
+    }
+    catch (err) {
+        if (process.env.NODE_ENV === 'test') {
+            throw err;
+        }
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Error occurred', err);
+        overallProgress.addErrorWithoutUpload({
+            chunk: null,
+            frame: null,
+            name: err.name,
+            stack: err.stack,
+            type: 'stitcher',
+            isFatal: true,
+            tmpDir: (0, write_error_to_storage_1.getTmpDirStateIfENoSp)(err.stack, providerSpecifics),
+            attempt: 1,
+            totalAttempts: 1,
+            willRetry: false,
+            message: err.message,
+        });
+        await overallProgress.upload();
+        runCleanupTasks();
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Wrote error to S3');
+        clearTimeout(webhookDueToTimeout);
+        if (params.webhook && !webhookInvoked) {
+            try {
+                await (0, invoke_webhook_1.invokeWebhook)({
+                    url: params.webhook.url,
+                    secret: params.webhook.secret,
+                    payload: {
+                        type: 'error',
+                        renderId: params.renderId,
+                        expectedBucketOwner: options.expectedBucketOwner,
+                        bucketName: params.bucketName,
+                        customData: (_c = params.webhook.customData) !== null && _c !== void 0 ? _c : null,
+                        errors: [err].map((e) => ({
+                            message: e.message,
+                            name: e.name,
+                            stack: e.stack,
+                        })),
+                    },
+                    redirectsSoFar: 0,
+                    client,
+                }, params.logLevel);
+                webhookInvoked = true;
+            }
+            catch (error) {
+                if (process.env.NODE_ENV === 'test') {
+                    throw error;
+                }
+                overallProgress.addErrorWithoutUpload({
+                    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,
+                });
+                overallProgress.upload();
+                renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to invoke webhook:');
+                renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, error);
+            }
+        }
+        throw err;
+    }
+    finally {
+        insideFunctionSpecifics.forgetBrowserEventLoop(params.logLevel);
+    }
+};
+exports.launchHandler = launchHandler;

package/dist/handlers/progress.d.ts

@@ -0,0 +1,16 @@
+import type { ServerlessPayload } from '../constants';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from '../provider-implementation';
+import type { GenericRenderProgress } from '../render-progress';
+import type { CloudProvider } from '../types';
+type Options<Provider extends CloudProvider> = {
+    expectedBucketOwner: string;
+    timeoutInMilliseconds: number;
+    retriesRemaining: number;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+};
+export declare const progressHandler: <Provider extends CloudProvider>({ params, options, }: {
+    params: ServerlessPayload<Provider>;
+    options: Options<Provider>;
+}) => Promise<GenericRenderProgress<Provider>>;
+export {};

package/dist/handlers/progress.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.progressHandler = void 0;
+const constants_1 = require("../constants");
+const progress_1 = require("../progress");
+const check_version_mismatch_1 = require("./check-version-mismatch");
+const progressHandler = async ({ params, options, }) => {
+    var _a;
+    if (params.type !== constants_1.ServerlessRoutines.status) {
+        throw new TypeError('Expected status type');
+    }
+    (0, check_version_mismatch_1.checkVersionMismatch)({
+        apiName: 'getRenderProgress()',
+        insideFunctionSpecifics: options.insideFunctionSpecifics,
+        params,
+    });
+    try {
+        const progress = await (0, progress_1.getProgress)({
+            bucketName: params.bucketName,
+            renderId: params.renderId,
+            expectedBucketOwner: options.expectedBucketOwner,
+            region: options.providerSpecifics.getCurrentRegionInFunction(),
+            memorySizeInMb: options.insideFunctionSpecifics.getCurrentMemorySizeInMb(),
+            timeoutInMilliseconds: options.timeoutInMilliseconds,
+            customCredentials: (_a = params.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
+            providerSpecifics: options.providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+            functionName: options.insideFunctionSpecifics.getCurrentFunctionName(),
+        });
+        return progress;
+    }
+    catch (err) {
+        if (options.retriesRemaining === 0) {
+            throw err;
+        }
+        if (err.message.includes('No render with ID')) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 1000);
+            });
+            return (0, exports.progressHandler)({
+                params,
+                options: {
+                    expectedBucketOwner: options.expectedBucketOwner,
+                    timeoutInMilliseconds: options.timeoutInMilliseconds,
+                    retriesRemaining: options.retriesRemaining - 1,
+                    providerSpecifics: options.providerSpecifics,
+                    insideFunctionSpecifics: options.insideFunctionSpecifics,
+                },
+            });
+        }
+        throw err;
+    }
+};
+exports.progressHandler = progressHandler;