@remotion/lambda 4.0.254 → 4.0.256

package/dist/functions/renderer.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rendererHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const pure_1 = require("@remotion/renderer/pure");
+const serverless_1 = require("@remotion/serverless");
+const client_1 = require("@remotion/serverless/client");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const version_1 = require("remotion/version");
+const constants_1 = require("../shared/constants");
+const is_flaky_error_1 = require("../shared/is-flaky-error");
+const why_is_node_running_1 = require("../shared/why-is-node-running");
+const can_concat_seamlessly_1 = require("./helpers/can-concat-seamlessly");
+const leak_detection_1 = require("./helpers/leak-detection");
+const on_downloads_logger_1 = require("./helpers/on-downloads-logger");
+const timer_1 = require("./helpers/timer");
+const renderHandler = async ({ params, options, logs, onStream, providerSpecifics, }) => {
+    if (params.type !== client_1.ServerlessRoutines.renderer) {
+        throw new Error('Params must be renderer');
+    }
+    if (params.launchFunctionConfig.version !== version_1.VERSION) {
+        throw new Error(`The version of the function that was specified as "rendererFunctionName" is ${version_1.VERSION} but the version of the function that invoked the render is ${params.launchFunctionConfig.version}. Please make sure that the version of the function that is specified as "rendererFunctionName" is the same as the version of the function that is invoked.`);
+    }
+    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 resolvedPropsPromise = (0, client_1.decompressInputProps)({
+        bucketName: params.bucketName,
+        expectedBucketOwner: options.expectedBucketOwner,
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        serialized: params.resolvedProps,
+        propsType: 'resolved-props',
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+    });
+    const browserInstance = await (0, serverless_1.getBrowserInstance)({
+        logLevel: params.logLevel,
+        indent: false,
+        chromiumOptions: params.chromiumOptions,
+        providerSpecifics,
+    });
+    const outputPath = renderer_1.RenderInternals.tmpDir('remotion-render-');
+    if (typeof params.chunk !== 'number') {
+        throw new Error('must pass chunk');
+    }
+    if (!params.frameRange) {
+        throw new Error('must pass framerange');
+    }
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Rendering frames ${params.frameRange[0]}-${params.frameRange[1]} in this Lambda function`);
+    const start = Date.now();
+    const chunkTimingData = {
+        timings: {},
+        chunk: params.chunk,
+        frameRange: params.frameRange,
+        startDate: start,
+    };
+    const outdir = renderer_1.RenderInternals.tmpDir(constants_1.RENDERER_PATH_TOKEN);
+    const chunk = `localchunk-${String(params.chunk).padStart(8, '0')}`;
+    const defaultAudioCodec = renderer_1.RenderInternals.getDefaultAudioCodec({
+        codec: params.codec,
+        preferLossless: params.preferLossless,
+    });
+    const seamlessAudio = (0, can_concat_seamlessly_1.canConcatAudioSeamlessly)(defaultAudioCodec, params.framesPerLambda);
+    const seamlessVideo = (0, can_concat_seamlessly_1.canConcatVideoSeamlessly)(params.codec);
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Preparing for rendering a chunk. Audio = ${seamlessAudio ? 'seamless' : 'normal'}, Video = ${seamlessVideo ? 'seamless' : 'normal'}`, params.logLevel);
+    const chunkCodec = seamlessVideo && params.codec === 'h264'
+        ? 'h264-ts'
+        : params.codec === 'gif'
+            ? 'h264-ts'
+            : params.codec;
+    const audioCodec = defaultAudioCodec === null
+        ? null
+        : seamlessAudio
+            ? defaultAudioCodec
+            : 'pcm-16';
+    const videoExtension = renderer_1.RenderInternals.getFileExtensionFromCodec(chunkCodec, audioCodec);
+    const audioExtension = audioCodec
+        ? renderer_1.RenderInternals.getExtensionFromAudioCodec(audioCodec)
+        : null;
+    const videoOutputLocation = node_path_1.default.join(outdir, `${chunk}.${videoExtension}`);
+    const willRenderAudioEval = renderer_1.RenderInternals.getShouldRenderAudio({
+        assetsInfo: null,
+        codec: params.codec,
+        enforceAudioTrack: true,
+        muted: params.muted,
+    });
+    if (willRenderAudioEval === 'maybe') {
+        throw new Error('Cannot determine whether to render audio or not');
+    }
+    const audioOutputLocation = willRenderAudioEval === 'no'
+        ? null
+        : pure_1.NoReactAPIs.isAudioCodec(params.codec)
+            ? null
+            : audioExtension
+                ? node_path_1.default.join(outdir, `${chunk}.${audioExtension}`)
+                : null;
+    const resolvedProps = await resolvedPropsPromise;
+    const serializedInputPropsWithCustomSchema = await inputPropsPromise;
+    const allFrames = renderer_1.RenderInternals.getFramesToRender(params.frameRange, params.everyNthFrame);
+    const onArtifact = (artifact) => {
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, `Received artifact on frame ${artifact.frame}:`, artifact.filename, artifact.content.length + 'bytes. Streaming to main function');
+        const startTimestamp = Date.now();
+        onStream({
+            type: 'artifact-emitted',
+            payload: {
+                artifact: (0, serverless_1.serializeArtifact)(artifact),
+            },
+        })
+            .then(() => {
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, `Streaming artifact ${artifact.filename} to main function took ${Date.now() - startTimestamp}ms`);
+        })
+            .catch((e) => {
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, `Error streaming artifact ${artifact.filename} to main function`, e);
+        });
+    };
+    await new Promise((resolve, reject) => {
+        var _a, _b, _c, _d, _e;
+        renderer_1.RenderInternals.internalRenderMedia({
+            repro: false,
+            composition: {
+                id: params.composition,
+                durationInFrames: params.durationInFrames,
+                fps: params.fps,
+                height: params.height,
+                width: params.width,
+                defaultCodec: null,
+            },
+            imageFormat: params.imageFormat,
+            serializedInputPropsWithCustomSchema,
+            frameRange: params.frameRange,
+            onProgress: ({ renderedFrames, encodedFrames, stitchStage }) => {
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Rendered ${renderedFrames} frames, encoded ${encodedFrames} frames, stage = ${stitchStage}`);
+                const allFramesRendered = allFrames.length === renderedFrames;
+                const allFramesEncoded = allFrames.length === encodedFrames;
+                const frameReportPoint = (renderedFrames % params.progressEveryNthFrame === 0 ||
+                    allFramesRendered) &&
+                    !allFramesEncoded;
+                const encodedFramesReportPoint = (encodedFrames % params.progressEveryNthFrame === 0 ||
+                    allFramesEncoded) &&
+                    allFramesRendered;
+                if (frameReportPoint || encodedFramesReportPoint) {
+                    onStream({
+                        type: 'frames-rendered',
+                        payload: { rendered: renderedFrames, encoded: encodedFrames },
+                    });
+                }
+                if (renderedFrames === allFrames.length) {
+                    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Rendered all frames!');
+                }
+                chunkTimingData.timings[renderedFrames] = Date.now() - start;
+            },
+            concurrency: params.concurrencyPerLambda,
+            onStart: () => {
+                onStream({
+                    type: 'lambda-invoked',
+                    payload: {
+                        attempt: params.attempt,
+                    },
+                });
+            },
+            puppeteerInstance: browserInstance.instance,
+            serveUrl: params.serveUrl,
+            jpegQuality: (_a = params.jpegQuality) !== null && _a !== void 0 ? _a : renderer_1.RenderInternals.DEFAULT_JPEG_QUALITY,
+            envVariables: (_b = params.envVariables) !== null && _b !== void 0 ? _b : {},
+            logLevel: params.logLevel,
+            onBrowserLog: (log) => {
+                logs.push(log);
+            },
+            outputLocation: videoOutputLocation,
+            codec: chunkCodec,
+            crf: (_c = params.crf) !== null && _c !== void 0 ? _c : null,
+            pixelFormat: (_d = params.pixelFormat) !== null && _d !== void 0 ? _d : renderer_1.RenderInternals.DEFAULT_PIXEL_FORMAT,
+            proResProfile: (_e = params.proResProfile) !== null && _e !== void 0 ? _e : undefined,
+            x264Preset: params.x264Preset,
+            onDownload: (0, on_downloads_logger_1.onDownloadsHelper)(params.logLevel),
+            overwrite: false,
+            chromiumOptions: params.chromiumOptions,
+            scale: params.scale,
+            timeoutInMilliseconds: params.timeoutInMilliseconds,
+            port: null,
+            everyNthFrame: params.everyNthFrame,
+            numberOfGifLoops: null,
+            muted: params.muted,
+            enforceAudioTrack: true,
+            audioBitrate: params.audioBitrate,
+            videoBitrate: params.videoBitrate,
+            encodingBufferSize: params.encodingBufferSize,
+            encodingMaxRate: params.encodingMaxRate,
+            audioCodec,
+            preferLossless: params.preferLossless,
+            browserExecutable: providerSpecifics.getChromiumPath(),
+            cancelSignal: undefined,
+            disallowParallelEncoding: false,
+            ffmpegOverride: ({ args }) => args,
+            indent: false,
+            onCtrlCExit: () => undefined,
+            server: undefined,
+            serializedResolvedPropsWithCustomSchema: resolvedProps,
+            offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+            colorSpace: params.colorSpace,
+            binariesDirectory: null,
+            separateAudioTo: audioOutputLocation,
+            forSeamlessAacConcatenation: seamlessAudio,
+            compositionStart: params.compositionStart,
+            onBrowserDownload: () => {
+                throw new Error('Should not download a browser in Lambda');
+            },
+            onArtifact,
+            metadata: params.metadata,
+            hardwareAcceleration: 'disable',
+        })
+            .then(({ slowestFrames }) => {
+            renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Slowest frames:`);
+            slowestFrames.forEach(({ frame, time }) => {
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `  Frame ${frame} (${time.toFixed(3)}ms)`);
+            });
+            resolve();
+        })
+            .catch((err) => reject(err));
+    });
+    const streamTimer = (0, timer_1.timer)('Streaming chunk to the main function', params.logLevel);
+    if (audioOutputLocation) {
+        const audioChunkTimer = (0, timer_1.timer)('Sending audio chunk', params.logLevel);
+        await onStream({
+            type: 'audio-chunk-rendered',
+            payload: node_fs_1.default.readFileSync(audioOutputLocation),
+        });
+        audioChunkTimer.end();
+    }
+    if (videoOutputLocation) {
+        const videoChunkTimer = (0, timer_1.timer)('Sending main chunk', params.logLevel);
+        await onStream({
+            type: pure_1.NoReactAPIs.isAudioCodec(params.codec)
+                ? 'audio-chunk-rendered'
+                : 'video-chunk-rendered',
+            payload: node_fs_1.default.readFileSync(videoOutputLocation),
+        });
+        videoChunkTimer.end();
+    }
+    const endRendered = Date.now();
+    await onStream({
+        type: 'chunk-complete',
+        payload: {
+            rendered: endRendered,
+            start,
+        },
+    });
+    streamTimer.end();
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Cleaning up and writing timings');
+    await Promise.all([
+        node_fs_1.default.promises.rm(videoOutputLocation, { recursive: true }),
+        audioOutputLocation
+            ? node_fs_1.default.promises.rm(audioOutputLocation, { recursive: true })
+            : null,
+        node_fs_1.default.promises.rm(outputPath, { recursive: true }),
+    ].filter(client_1.truthy));
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Done!');
+    return {};
+};
+const ENABLE_SLOW_LEAK_DETECTION = false;
+const rendererHandler = async ({ onStream, options, params, providerSpecifics, requestContext, }) => {
+    if (params.type !== client_1.ServerlessRoutines.renderer) {
+        throw new Error('Params must be renderer');
+    }
+    const logs = [];
+    const leakDetection = (0, why_is_node_running_1.enableNodeIntrospection)(ENABLE_SLOW_LEAK_DETECTION);
+    let shouldKeepBrowserOpen = true;
+    try {
+        await renderHandler({
+            params,
+            options,
+            logs,
+            onStream,
+            providerSpecifics,
+        });
+        return {
+            type: 'success',
+        };
+    }
+    catch (err) {
+        if (process.env.NODE_ENV === 'test') {
+            console.log({ err });
+            throw err;
+        }
+        // If this error is encountered, we can just retry as it
+        // is a very rare error to occur
+        const isRetryableError = (0, is_flaky_error_1.isFlakyError)(err);
+        if (isRetryableError) {
+            shouldKeepBrowserOpen = false;
+        }
+        const shouldNotRetry = err.name === 'CancelledError';
+        const shouldRetry = isRetryableError && params.retriesLeft > 0 && !shouldNotRetry;
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, `Error occurred (will retry = ${String(shouldRetry)})`);
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, err.stack);
+        onStream({
+            type: 'error-occurred',
+            payload: {
+                error: err.stack,
+                shouldRetry,
+                errorInfo: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                    chunk: params.chunk,
+                    frame: null,
+                    type: 'renderer',
+                    isFatal: !shouldRetry,
+                    tmpDir: (0, serverless_1.getTmpDirStateIfENoSp)(err.stack, providerSpecifics),
+                    attempt: params.attempt,
+                    totalAttempts: params.retriesLeft + params.attempt,
+                    willRetry: shouldRetry,
+                },
+            },
+        });
+        throw err;
+    }
+    finally {
+        if (shouldKeepBrowserOpen) {
+            (0, serverless_1.forgetBrowserEventLoop)(params.logLevel);
+        }
+        else {
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Lambda did not succeed with flaky error, not keeping browser open.');
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Quitting Lambda forcefully now to force not keeping the Lambda warm.');
+            process.exit(0);
+        }
+        if (ENABLE_SLOW_LEAK_DETECTION) {
+            (0, leak_detection_1.startLeakDetection)(leakDetection, requestContext.awsRequestId);
+        }
+    }
+};
+exports.rendererHandler = rendererHandler;

package/dist/functions/start.d.ts

@@ -0,0 +1,13 @@
+import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
+type Options = {
+    expectedBucketOwner: string;
+    timeoutInMilliseconds: number;
+    renderId: string;
+};
+export declare const startHandler: <Provider extends CloudProvider>(params: ServerlessPayload<Provider>, options: Options, providerSpecifics: ProviderSpecifics<Provider>) => Promise<{
+    type: "success";
+    bucketName: string;
+    renderId: string;
+}>;
+export {};

package/dist/functions/start.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startHandler = void 0;
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const client_1 = require("@remotion/serverless/client");
+const version_1 = require("remotion/version");
+const aws_clients_1 = require("../shared/aws-clients");
+const lifecycle_1 = require("./helpers/lifecycle");
+const overall_render_progress_1 = require("./helpers/overall-render-progress");
+const startHandler = async (params, options, providerSpecifics) => {
+    var _a, _b, _c, _d;
+    if (params.type !== client_1.ServerlessRoutines.start) {
+        throw new TypeError('Expected type start');
+    }
+    if (params.version !== version_1.VERSION) {
+        if (!params.version) {
+            throw new Error(`Version mismatch: When calling renderMediaOnLambda(), 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 renderMediaOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
+        }
+        throw new Error(`Version mismatch: When calling renderMediaOnLambda(), 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 ${params.version}. Deploy a new function and use it to call renderMediaOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
+    }
+    const region = providerSpecifics.getCurrentRegionInFunction();
+    const bucketName = (_a = params.bucketName) !== null && _a !== void 0 ? _a : (await (0, client_1.internalGetOrCreateBucket)({
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        enableFolderExpiry: null,
+        customCredentials: null,
+        providerSpecifics,
+        forcePathStyle: params.forcePathStyle,
+    })).bucketName;
+    const realServeUrl = providerSpecifics.convertToServeUrl({
+        urlOrId: params.serveUrl,
+        region,
+        bucketName,
+    });
+    (0, lifecycle_1.validateDeleteAfter)(params.deleteAfter);
+    const initialFile = providerSpecifics.writeFile({
+        bucketName,
+        downloadBehavior: null,
+        region,
+        body: JSON.stringify((0, overall_render_progress_1.makeInitialOverallRenderProgress)(options.timeoutInMilliseconds + Date.now())),
+        expectedBucketOwner: options.expectedBucketOwner,
+        key: (0, client_1.overallProgressKey)(options.renderId),
+        privacy: 'private',
+        customCredentials: null,
+        forcePathStyle: params.forcePathStyle,
+    });
+    const payload = {
+        type: client_1.ServerlessRoutines.launch,
+        framesPerLambda: params.framesPerLambda,
+        composition: params.composition,
+        serveUrl: realServeUrl,
+        inputProps: params.inputProps,
+        bucketName,
+        renderId: options.renderId,
+        codec: params.codec,
+        imageFormat: params.imageFormat,
+        crf: (_b = params.crf) !== null && _b !== void 0 ? _b : null,
+        envVariables: params.envVariables,
+        pixelFormat: (_c = params.pixelFormat) !== null && _c !== void 0 ? _c : null,
+        proResProfile: (_d = params.proResProfile) !== null && _d !== void 0 ? _d : null,
+        x264Preset: params.x264Preset,
+        jpegQuality: params.jpegQuality,
+        maxRetries: params.maxRetries,
+        privacy: params.privacy,
+        logLevel: params.logLevel,
+        frameRange: params.frameRange,
+        outName: params.outName,
+        timeoutInMilliseconds: params.timeoutInMilliseconds,
+        chromiumOptions: params.chromiumOptions,
+        scale: params.scale,
+        numberOfGifLoops: params.numberOfGifLoops,
+        everyNthFrame: params.everyNthFrame,
+        concurrencyPerLambda: params.concurrencyPerLambda,
+        downloadBehavior: params.downloadBehavior,
+        muted: params.muted,
+        overwrite: params.overwrite,
+        webhook: params.webhook,
+        audioBitrate: params.audioBitrate,
+        videoBitrate: params.videoBitrate,
+        encodingBufferSize: params.encodingBufferSize,
+        encodingMaxRate: params.encodingMaxRate,
+        forceHeight: params.forceHeight,
+        forceWidth: params.forceWidth,
+        rendererFunctionName: params.rendererFunctionName,
+        audioCodec: params.audioCodec,
+        offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+        deleteAfter: params.deleteAfter,
+        colorSpace: params.colorSpace,
+        preferLossless: params.preferLossless,
+        forcePathStyle: params.forcePathStyle,
+        metadata: params.metadata,
+    };
+    const stringifiedPayload = JSON.stringify(payload);
+    if (stringifiedPayload.length > 256 * 1024) {
+        throw new Error(`Payload is too big: ${stringifiedPayload.length} bytes. Maximum size is 256 KB. This should not happen, please report this to the Remotion team. Payload: ${stringifiedPayload}`);
+    }
+    // Don't replace with callLambda(), we want to return before the render is snone
+    const result = await (0, aws_clients_1.getLambdaClient)(providerSpecifics.getCurrentRegionInFunction()).send(new client_lambda_1.InvokeCommand({
+        FunctionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+        Payload: stringifiedPayload,
+        InvocationType: 'Event',
+    }));
+    if (result.FunctionError) {
+        throw new Error(`Lambda function returned error: ${result.FunctionError} ${result.LogResult}`);
+    }
+    await initialFile;
+    return {
+        type: 'success',
+        bucketName,
+        renderId: options.renderId,
+    };
+};
+exports.startHandler = startHandler;

package/dist/functions/still.d.ts

@@ -0,0 +1,19 @@
+import type { CloudProvider, OnStream } from '@remotion/serverless';
+import { type ProviderSpecifics } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
+type Options<Provider extends CloudProvider> = {
+    params: ServerlessPayload<Provider>;
+    renderId: string;
+    expectedBucketOwner: string;
+    onStream: OnStream<Provider>;
+    timeoutInMilliseconds: number;
+    providerSpecifics: ProviderSpecifics<Provider>;
+};
+export declare const stillHandler: <Provider extends CloudProvider>(options: Options<Provider>) => Promise<{
+    type: "success";
+} | {
+    type: "error";
+    message: string;
+    stack: string;
+}>;
+export {};