@remotion/lambda 4.0.256 → 4.0.258

package/dist/functions/launch.js

@@ -1,595 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.launchHandler = void 0;
-const renderer_1 = require("@remotion/renderer");
-const serverless_1 = require("@remotion/serverless");
-const client_1 = require("@remotion/serverless/client");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const version_1 = require("remotion/version");
-const constants_1 = require("../shared/constants");
-const docs_url_1 = require("../shared/docs-url");
-const invoke_webhook_1 = require("../shared/invoke-webhook");
-const validate_1 = require("../shared/validate");
-const validate_frames_per_lambda_1 = require("../shared/validate-frames-per-lambda");
-const validate_privacy_1 = require("../shared/validate-privacy");
-const plan_frame_ranges_1 = require("./chunk-optimization/plan-frame-ranges");
-const best_frames_per_lambda_param_1 = require("./helpers/best-frames-per-lambda-param");
-const cleanup_props_1 = require("./helpers/cleanup-props");
-const find_output_file_in_bucket_1 = require("./helpers/find-output-file-in-bucket");
-const merge_chunks_1 = require("./helpers/merge-chunks");
-const overall_render_progress_1 = require("./helpers/overall-render-progress");
-const stream_renderer_1 = require("./helpers/stream-renderer");
-const timer_1 = require("./helpers/timer");
-const innerLaunchHandler = async ({ functionName, params, options, overallProgress, registerCleanupTask, providerSpecifics, }) => {
-    var _a, _b, _c, _d, _e, _f, _g;
-    if (params.type !== client_1.ServerlessRoutines.launch) {
-        throw new Error('Expected launch type');
-    }
-    const startedDate = Date.now();
-    const browserInstance = (0, serverless_1.getBrowserInstance)({
-        logLevel: params.logLevel,
-        indent: false,
-        chromiumOptions: params.chromiumOptions,
-        providerSpecifics,
-    });
-    const inputPropsPromise = (0, client_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, serverless_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 Lambda');
-        },
-        onServeUrlVisited: () => {
-            overallProgress.setServeUrlOpened(Date.now());
-        },
-        providerSpecifics,
-    });
-    overallProgress.setCompositionValidated(Date.now());
-    renderer_1.RenderInternals.Log.info(logOptions, 'Composition validated, resolved props', comp.props);
-    (0, validate_1.validateDurationInFrames)(comp.durationInFrames, {
-        component: 'passed to a Lambda render',
-        allowFloats: false,
-    });
-    (0, validate_1.validateFps)(comp.fps, 'passed to a Lambda render', false);
-    (0, validate_1.validateDimension)(comp.height, 'height', 'passed to a Lambda render');
-    (0, validate_1.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({
-        value: params.concurrencyPerLambda,
-        setting: 'concurrencyPerLambda',
-        checkIfValidForCurrentMachine: true,
-    });
-    const realFrameRange = renderer_1.RenderInternals.getRealFrameRange(comp.durationInFrames, params.frameRange);
-    const frameCount = renderer_1.RenderInternals.getFramesToRender(realFrameRange, params.everyNthFrame);
-    const framesPerLambda = (_b = params.framesPerLambda) !== null && _b !== void 0 ? _b : (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(frameCount.length);
-    (0, validate_frames_per_lambda_1.validateFramesPerLambda)({
-        framesPerLambda,
-        durationInFrames: frameCount.length,
-    });
-    (0, serverless_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)({
-        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, client_1.serializeOrThrow)(comp.props, 'resolved-props');
-    const needsToUpload = (0, client_1.getNeedsToUpload)('video-or-audio', [
-        serializedResolved.length,
-        params.inputProps.type === 'bucket-url'
-            ? params.inputProps.hash.length
-            : params.inputProps.payload.length,
-        JSON.stringify(params.envVariables).length,
-    ]);
-    const serializedResolvedProps = await (0, client_1.compressInputProps)({
-        propsType: 'resolved-props',
-        region: providerSpecifics.getCurrentRegionInFunction(),
-        stringifiedInputProps: serializedResolved,
-        userSpecifiedBucketName: params.bucketName,
-        needsToUpload,
-        providerSpecifics,
-        forcePathStyle: params.forcePathStyle,
-    });
-    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: client_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.concurrencyPerLambda,
-            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: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
-        region: providerSpecifics.getCurrentRegionInFunction(),
-        renderId: params.renderId,
-        outName: (_c = params.outName) !== null && _c !== void 0 ? _c : 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: process.env.AWS_LAMBDA_FUNCTION_NAME,
-        dimensions: {
-            width: comp.width * ((_d = params.scale) !== null && _d !== void 0 ? _d : 1),
-            height: comp.height * ((_e = params.scale) !== null && _e !== void 0 ? _e : 1),
-        },
-    };
-    const { key, renderBucketName, customCredentials } = (0, client_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
-        ? null
-        : ((_g = (_f = params.outName) === null || _f === void 0 ? void 0 : _f.s3OutputProvider) !== null && _g !== void 0 ? _g : null));
-    if (!params.overwrite) {
-        const findOutputFile = (0, timer_1.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, client_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,
-    });
-    return postRenderData;
-};
-const launchHandler = async (params, options, providerSpecifics) => {
-    var _a, _b, _c;
-    if (params.type !== client_1.ServerlessRoutines.launch) {
-        throw new Error('Expected launch type');
-    }
-    const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : process.env.AWS_LAMBDA_FUNCTION_NAME;
-    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,
-            }, 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,
-        });
-        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,
-            }, 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, serverless_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,
-                }, 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 {
-        (0, serverless_1.forgetBrowserEventLoop)(params.logLevel);
-    }
-};
-exports.launchHandler = launchHandler;

package/dist/functions/progress.d.ts

@@ -1,11 +0,0 @@
-import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless';
-import type { ServerlessPayload } from '@remotion/serverless/client';
-import type { GenericRenderProgress } from '../shared/constants';
-type Options<Provider extends CloudProvider> = {
-    expectedBucketOwner: string;
-    timeoutInMilliseconds: number;
-    retriesRemaining: number;
-    providerSpecifics: ProviderSpecifics<Provider>;
-};
-export declare const progressHandler: <Provider extends CloudProvider>(lambdaParams: ServerlessPayload<Provider>, options: Options<Provider>) => Promise<GenericRenderProgress<Provider>>;
-export {};

package/dist/functions/progress.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.progressHandler = void 0;
-const client_1 = require("@remotion/serverless/client");
-const version_1 = require("remotion/version");
-const get_progress_1 = require("./helpers/get-progress");
-const progressHandler = async (lambdaParams, options) => {
-    var _a;
-    if (lambdaParams.type !== client_1.ServerlessRoutines.status) {
-        throw new TypeError('Expected status type');
-    }
-    if (lambdaParams.version !== version_1.VERSION) {
-        if (!lambdaParams.version) {
-            throw new Error(`Version mismatch: When calling getRenderProgress(), 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 getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
-        }
-        throw new Error(`Version mismatch: When calling getRenderProgress(), 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 getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
-    }
-    try {
-        const progress = await (0, get_progress_1.getProgress)({
-            bucketName: lambdaParams.bucketName,
-            renderId: lambdaParams.renderId,
-            expectedBucketOwner: options.expectedBucketOwner,
-            region: options.providerSpecifics.getCurrentRegionInFunction(),
-            memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
-            timeoutInMilliseconds: options.timeoutInMilliseconds,
-            customCredentials: (_a = lambdaParams.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
-            providerSpecifics: options.providerSpecifics,
-            forcePathStyle: lambdaParams.forcePathStyle,
-            functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
-        });
-        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)(lambdaParams, {
-                expectedBucketOwner: options.expectedBucketOwner,
-                timeoutInMilliseconds: options.timeoutInMilliseconds,
-                retriesRemaining: options.retriesRemaining - 1,
-                providerSpecifics: options.providerSpecifics,
-            });
-        }
-        throw err;
-    }
-};
-exports.progressHandler = progressHandler;

package/dist/functions/renderer.d.ts

@@ -1,17 +0,0 @@
-import type { CloudProvider, OnStream, ProviderSpecifics } from '@remotion/serverless';
-import type { ServerlessPayload } from '@remotion/serverless/client';
-import type { RequestContext } from './helpers/request-context';
-type Options = {
-    expectedBucketOwner: string;
-    isWarm: boolean;
-};
-export declare const rendererHandler: <Provider extends CloudProvider>({ onStream, options, params, providerSpecifics, requestContext, }: {
-    params: ServerlessPayload<Provider>;
-    options: Options;
-    onStream: OnStream<Provider>;
-    requestContext: RequestContext;
-    providerSpecifics: ProviderSpecifics<Provider>;
-}) => Promise<{
-    type: "success";
-}>;
-export {};