@remotion/lambda 4.0.254 → 4.0.256

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

@@ -0,0 +1,10 @@
+import type { CloudProvider } from '@remotion/serverless';
+import type { RenderMetadata } from '@remotion/serverless/client';
+export declare const makeTimeoutMessage: <Provider extends CloudProvider>({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, }: {
+    timeoutInMilliseconds: number;
+    missingChunks: number[];
+    renderMetadata: RenderMetadata<Provider>;
+    renderId: string;
+    region: Provider["region"];
+    functionName: string;
+}) => string;

package/dist/functions/helpers/make-timeout-message.js

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

package/dist/functions/helpers/merge-chunks.d.ts

@@ -0,0 +1,36 @@
+import type { AudioCodec, LogLevel } from '@remotion/renderer';
+import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless';
+import type { CustomCredentials, DownloadBehavior, Privacy, RenderMetadata, SerializedInputProps, ServerlessCodec } from '@remotion/serverless/client';
+import type { PostRenderData } from '../../shared/constants';
+import type { OverallProgressHelper } from './overall-render-progress';
+export declare const mergeChunksAndFinishRender: <Provider extends CloudProvider>(options: {
+    bucketName: string;
+    renderId: string;
+    expectedBucketOwner: string;
+    numberOfFrames: number;
+    codec: ServerlessCodec;
+    chunkCount: number;
+    fps: number;
+    numberOfGifLoops: number | null;
+    audioCodec: AudioCodec | null;
+    renderBucketName: string;
+    customCredentials: CustomCredentials<Provider> | null;
+    downloadBehavior: DownloadBehavior;
+    key: string;
+    privacy: Privacy;
+    inputProps: SerializedInputProps;
+    serializedResolvedProps: SerializedInputProps;
+    renderMetadata: RenderMetadata<Provider>;
+    audioBitrate: string | null;
+    logLevel: LogLevel;
+    framesPerLambda: number;
+    binariesDirectory: string | null;
+    preferLossless: boolean;
+    compositionStart: number;
+    outdir: string;
+    files: string[];
+    overallProgress: OverallProgressHelper<Provider>;
+    startTime: number;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<PostRenderData<Provider>>;

package/dist/functions/helpers/merge-chunks.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeChunksAndFinishRender = void 0;
+const fs_1 = __importDefault(require("fs"));
+const cleanup_props_1 = require("./cleanup-props");
+const concat_videos_1 = require("./concat-videos");
+const create_post_render_data_1 = require("./create-post-render-data");
+const get_output_url_from_metadata_1 = require("./get-output-url-from-metadata");
+const inspect_errors_1 = require("./inspect-errors");
+const timer_1 = require("./timer");
+const mergeChunksAndFinishRender = async (options) => {
+    const onProgress = (framesEncoded) => {
+        options.overallProgress.setCombinedFrames(framesEncoded);
+    };
+    const encodingStart = Date.now();
+    if (options.renderMetadata.type === 'still') {
+        throw new Error('Cannot merge stills');
+    }
+    const { outfile, cleanupChunksProm } = await (0, concat_videos_1.concatVideos)({
+        onProgress,
+        numberOfFrames: options.numberOfFrames,
+        codec: options.codec,
+        fps: options.fps,
+        numberOfGifLoops: options.numberOfGifLoops,
+        files: options.files,
+        outdir: options.outdir,
+        audioCodec: options.audioCodec,
+        audioBitrate: options.audioBitrate,
+        logLevel: options.logLevel,
+        framesPerLambda: options.framesPerLambda,
+        binariesDirectory: options.binariesDirectory,
+        cancelSignal: undefined,
+        preferLossless: options.preferLossless,
+        muted: options.renderMetadata.muted,
+        metadata: options.renderMetadata.metadata,
+    });
+    const encodingStop = Date.now();
+    options.overallProgress.setTimeToCombine(encodingStop - encodingStart);
+    const outputSize = fs_1.default.statSync(outfile).size;
+    const writeToBucket = (0, timer_1.timer)(`Writing to bucket (${outputSize} bytes)`, options.logLevel);
+    await options.providerSpecifics.writeFile({
+        bucketName: options.renderBucketName,
+        key: options.key,
+        body: fs_1.default.createReadStream(outfile),
+        region: options.providerSpecifics.getCurrentRegionInFunction(),
+        privacy: options.privacy,
+        expectedBucketOwner: options.expectedBucketOwner,
+        downloadBehavior: options.downloadBehavior,
+        customCredentials: options.customCredentials,
+        forcePathStyle: options.forcePathStyle,
+    });
+    writeToBucket.end();
+    const errorExplanations = (0, inspect_errors_1.inspectErrors)({
+        errors: options.overallProgress.get().errors,
+    });
+    const cleanupProm = (0, cleanup_props_1.cleanupProps)({
+        inputProps: options.inputProps,
+        serializedResolvedProps: options.serializedResolvedProps,
+        providerSpecifics: options.providerSpecifics,
+        forcePathStyle: options.forcePathStyle,
+    });
+    const { url: outputUrl } = (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(options.renderMetadata, options.bucketName, options.customCredentials, options.providerSpecifics.getCurrentRegionInFunction());
+    const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
+        region: options.providerSpecifics.getCurrentRegionInFunction(),
+        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+        renderMetadata: options.renderMetadata,
+        errorExplanations,
+        timeToDelete: (await cleanupProm).reduce((a, b) => Math.max(a, b), 0),
+        outputFile: {
+            url: outputUrl,
+        },
+        outputSize,
+        timeToCombine: encodingStop - encodingStart,
+        overallProgress: options.overallProgress.get(),
+        timeToFinish: Date.now() - options.startTime,
+    });
+    options.overallProgress.setPostRenderData(postRenderData);
+    await Promise.all([cleanupChunksProm, fs_1.default.promises.rm(outfile)]);
+    return postRenderData;
+};
+exports.mergeChunksAndFinishRender = mergeChunksAndFinishRender;

package/dist/functions/helpers/min-max.d.ts

@@ -0,0 +1,2 @@
+export declare const min: (arr: number[]) => number;
+export declare const max: (arr: number[]) => number;

package/dist/functions/helpers/min-max.js

@@ -0,0 +1,33 @@
+"use strict";
+// Standard library Math.min and Math.max can throw
+// if array length is very long. Fixing this with own implementation
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.max = exports.min = void 0;
+const min = (arr) => {
+    if (arr.length === 0) {
+        throw new Error('Array of 0 length');
+    }
+    let smallest = arr[0];
+    for (let i = 0; i < arr.length; i++) {
+        const elem = arr[i];
+        if (elem < smallest) {
+            smallest = elem;
+        }
+    }
+    return smallest;
+};
+exports.min = min;
+const max = (arr) => {
+    if (arr.length === 0) {
+        throw new Error('Array of 0 length');
+    }
+    let biggest = arr[0];
+    for (let i = 0; i < arr.length; i++) {
+        const elem = arr[i];
+        if (elem > biggest) {
+            biggest = elem;
+        }
+    }
+    return biggest;
+};
+exports.max = max;

package/dist/functions/helpers/on-downloads-logger.d.ts

@@ -0,0 +1,2 @@
+import type { LogLevel, RenderMediaOnDownload } from '@remotion/renderer';
+export declare const onDownloadsHelper: (logLevel: LogLevel) => RenderMediaOnDownload;

package/dist/functions/helpers/on-downloads-logger.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onDownloadsHelper = void 0;
+const renderer_1 = require("@remotion/renderer");
+const onDownloadsHelper = (logLevel) => {
+    const downloads = {};
+    return (src) => {
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Downloading', src);
+        downloads[src] = 0;
+        return ({ percent, downloaded }) => {
+            if (percent === null) {
+                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Download progress (${src}): ${downloaded} bytes. Don't know final size of download, no Content-Length header.`);
+                return;
+            }
+            if (
+            // Only report every 10% change
+            downloads[src] > percent - 0.1 &&
+                percent !== 1) {
+                return;
+            }
+            downloads[src] = percent;
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Download progress (${src}): ${downloaded} bytes, ${(percent * 100).toFixed(1)}%`);
+            if (percent === 1) {
+                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Download complete: ${src}`);
+            }
+        };
+    };
+};
+exports.onDownloadsHelper = onDownloadsHelper;

package/dist/functions/helpers/overall-render-progress.d.ts

@@ -0,0 +1,59 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { CloudProvider, LambdaErrorInfo, ProviderSpecifics, ReceivedArtifact } from '@remotion/serverless';
+import { type RenderMetadata } from '@remotion/serverless/client';
+import type { PostRenderData } from '../../shared/constants';
+import type { ParsedTiming } from '../../shared/parse-lambda-timings-key';
+import type { ChunkRetry } from './get-retry-stats';
+export type OverallRenderProgress<Provider extends CloudProvider> = {
+    chunks: number[];
+    framesRendered: number;
+    framesEncoded: number;
+    combinedFrames: number;
+    timeToCombine: number | null;
+    timeToEncode: number | null;
+    timeToRenderFrames: number | null;
+    lambdasInvoked: number;
+    retries: ChunkRetry[];
+    postRenderData: PostRenderData<Provider> | null;
+    timings: ParsedTiming[];
+    renderMetadata: RenderMetadata<Provider> | null;
+    errors: LambdaErrorInfo[];
+    timeoutTimestamp: number;
+    functionLaunched: number;
+    serveUrlOpened: number | null;
+    compositionValidated: number | null;
+    receivedArtifact: ReceivedArtifact<Provider>[];
+};
+export type OverallProgressHelper<Provider extends CloudProvider> = {
+    upload: () => Promise<void>;
+    setFrames: ({ encoded, rendered, index, }: {
+        rendered: number;
+        encoded: number;
+        index: number;
+    }) => void;
+    setLambdaInvoked: (chunk: number) => void;
+    addChunkCompleted: (chunkIndex: number, start: number, rendered: number) => void;
+    setCombinedFrames: (framesEncoded: number) => void;
+    setTimeToCombine: (timeToCombine: number) => void;
+    addRetry: (retry: ChunkRetry) => void;
+    setPostRenderData: (postRenderData: PostRenderData<Provider>) => void;
+    setRenderMetadata: (renderMetadata: RenderMetadata<Provider>) => void;
+    addErrorWithoutUpload: (errorInfo: LambdaErrorInfo) => void;
+    setExpectedChunks: (expectedChunks: number) => void;
+    get: () => OverallRenderProgress<Provider>;
+    setServeUrlOpened: (timestamp: number) => void;
+    setCompositionValidated: (timestamp: number) => void;
+    addReceivedArtifact: (asset: ReceivedArtifact<Provider>) => void;
+    getReceivedArtifacts: () => ReceivedArtifact<Provider>[];
+};
+export declare const makeInitialOverallRenderProgress: <Provider extends CloudProvider>(timeoutTimestamp: number) => OverallRenderProgress<Provider>;
+export declare const makeOverallRenderProgress: <Provider extends CloudProvider>({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, }: {
+    renderId: string;
+    bucketName: string;
+    expectedBucketOwner: string;
+    region: Provider["region"];
+    timeoutTimestamp: number;
+    logLevel: LogLevel;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => OverallProgressHelper<Provider>;

package/dist/functions/helpers/overall-render-progress.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOverallRenderProgress = exports.makeInitialOverallRenderProgress = void 0;
+const renderer_1 = require("@remotion/renderer");
+const client_1 = require("@remotion/serverless/client");
+const makeInitialOverallRenderProgress = (timeoutTimestamp) => {
+    return {
+        chunks: [],
+        framesRendered: 0,
+        framesEncoded: 0,
+        combinedFrames: 0,
+        timeToCombine: null,
+        timeToEncode: null,
+        lambdasInvoked: 0,
+        retries: [],
+        postRenderData: null,
+        timings: [],
+        renderMetadata: null,
+        errors: [],
+        timeToRenderFrames: null,
+        timeoutTimestamp,
+        functionLaunched: Date.now(),
+        serveUrlOpened: null,
+        compositionValidated: null,
+        receivedArtifact: [],
+    };
+};
+exports.makeInitialOverallRenderProgress = makeInitialOverallRenderProgress;
+const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, }) => {
+    let framesRendered = [];
+    let framesEncoded = [];
+    let lambdasInvoked = [];
+    const renderProgress = (0, exports.makeInitialOverallRenderProgress)(timeoutTimestamp);
+    let currentUploadPromise = null;
+    const getCurrentProgress = () => renderProgress;
+    let latestUploadRequest = 0;
+    const getLatestRequestId = () => latestUploadRequest;
+    let encodeStartTime = null;
+    let renderFramesStartTime = null;
+    const upload = async () => {
+        const uploadRequestId = ++latestUploadRequest;
+        if (currentUploadPromise) {
+            await currentUploadPromise;
+        }
+        // If request has been replaced by a new one
+        if (getLatestRequestId() !== uploadRequestId) {
+            return;
+        }
+        const toWrite = JSON.stringify(getCurrentProgress());
+        const start = Date.now();
+        currentUploadPromise = providerSpecifics
+            .writeFile({
+            body: toWrite,
+            bucketName,
+            customCredentials: null,
+            downloadBehavior: null,
+            expectedBucketOwner,
+            key: (0, client_1.overallProgressKey)(renderId),
+            privacy: 'private',
+            region,
+            forcePathStyle,
+        })
+            .then(() => {
+            // By default, upload is way too fast (~20 requests per second)
+            // Space out the requests a bit
+            return new Promise((resolve) => {
+                setTimeout(resolve, 250 - (Date.now() - start));
+            });
+        })
+            .catch((err) => {
+            // If an error occurs in uploading the state that contains the errors,
+            // that is unfortunate. We just log it.
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, 'Error uploading progress', err);
+        });
+        await currentUploadPromise;
+        currentUploadPromise = null;
+    };
+    return {
+        upload,
+        setFrames: ({ encoded, rendered, index, }) => {
+            if (framesRendered.length === 0) {
+                throw new Error('Expected chunks to be set before frames are set');
+            }
+            if (framesEncoded.length === 0) {
+                throw new Error('Expected chunks to be set before frames are set');
+            }
+            framesRendered[index] = rendered;
+            framesEncoded[index] = encoded;
+            const totalFramesEncoded = framesEncoded.reduce((a, b) => a + b, 0);
+            const totalFramesRendered = framesRendered.reduce((a, b) => a + b, 0);
+            if (renderProgress.framesEncoded === 0 && totalFramesEncoded > 0) {
+                encodeStartTime = Date.now();
+            }
+            if (renderProgress.framesRendered === 0 && totalFramesRendered > 0) {
+                renderFramesStartTime = Date.now();
+            }
+            if (renderProgress.timeToRenderFrames === null) {
+                const frameCount = renderProgress.renderMetadata &&
+                    renderProgress.renderMetadata.type === 'video'
+                    ? renderer_1.RenderInternals.getFramesToRender(renderProgress.renderMetadata.frameRange, renderProgress.renderMetadata.everyNthFrame).length
+                    : null;
+                if (frameCount === totalFramesRendered) {
+                    const timeToRenderFrames = Date.now() - (renderFramesStartTime !== null && renderFramesStartTime !== void 0 ? renderFramesStartTime : Date.now());
+                    renderProgress.timeToRenderFrames = timeToRenderFrames;
+                }
+            }
+            renderProgress.framesRendered = totalFramesRendered;
+            renderProgress.framesEncoded = totalFramesEncoded;
+            upload();
+        },
+        addChunkCompleted: (chunkIndex, start, rendered) => {
+            var _a;
+            renderProgress.chunks.push(chunkIndex);
+            if (renderProgress.chunks.length ===
+                ((_a = renderProgress.renderMetadata) === null || _a === void 0 ? void 0 : _a.totalChunks)) {
+                const timeToEncode = Date.now() - (encodeStartTime !== null && encodeStartTime !== void 0 ? encodeStartTime : Date.now());
+                renderProgress.timeToEncode = timeToEncode;
+            }
+            renderProgress.timings.push({
+                chunk: chunkIndex,
+                start,
+                rendered,
+            });
+            upload();
+        },
+        setCombinedFrames: (frames) => {
+            renderProgress.combinedFrames = frames;
+            upload();
+        },
+        setTimeToCombine: (timeToCombine) => {
+            renderProgress.timeToCombine = timeToCombine;
+            upload();
+        },
+        setLambdaInvoked(chunk) {
+            if (lambdasInvoked.length === 0) {
+                throw new Error('Expected chunks to be set before lambdas are set');
+            }
+            lambdasInvoked[chunk] = true;
+            renderProgress.lambdasInvoked = lambdasInvoked.reduce((a, b) => a + Number(b), 0);
+            upload();
+        },
+        setPostRenderData(postRenderData) {
+            renderProgress.postRenderData = postRenderData;
+            upload();
+        },
+        setRenderMetadata: (renderMetadata) => {
+            renderProgress.renderMetadata = renderMetadata;
+            upload();
+        },
+        addErrorWithoutUpload: (errorInfo) => {
+            renderProgress.errors.push(errorInfo);
+        },
+        setExpectedChunks: (expectedChunks) => {
+            framesRendered = new Array(expectedChunks).fill(0);
+            framesEncoded = new Array(expectedChunks).fill(0);
+            lambdasInvoked = new Array(expectedChunks).fill(false);
+        },
+        setCompositionValidated(timestamp) {
+            renderProgress.compositionValidated = timestamp;
+            upload();
+        },
+        setServeUrlOpened(timestamp) {
+            renderProgress.serveUrlOpened = timestamp;
+            upload();
+        },
+        addRetry(retry) {
+            renderProgress.retries.push(retry);
+            upload();
+        },
+        addReceivedArtifact(asset) {
+            renderProgress.receivedArtifact.push(asset);
+            upload();
+        },
+        getReceivedArtifacts() {
+            return renderProgress.receivedArtifact;
+        },
+        get: () => renderProgress,
+    };
+};
+exports.makeOverallRenderProgress = makeOverallRenderProgress;

package/dist/functions/helpers/print-concurrency-curve.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/functions/helpers/print-concurrency-curve.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const best_frames_per_lambda_param_1 = require("./best-frames-per-lambda-param");
+const entries = [];
+for (let i = 0; i < 18000; i += 100) {
+    entries.push([i, (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(i)]);
+}
+console.log(entries.map((e) => e.join(',')).join('\n'));

package/dist/functions/helpers/print-logging-helper.d.ts

@@ -0,0 +1,4 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { ServerlessRoutines } from '@remotion/serverless/client';
+export type PrintLoggingHelper = (type: ServerlessRoutines, data: Record<string, string | boolean>, logLevel: LogLevel) => void;
+export declare const printLoggingGrepHelper: PrintLoggingHelper;

package/dist/functions/helpers/print-logging-helper.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printLoggingGrepHelper = void 0;
+const renderer_1 = require("@remotion/renderer");
+const printLoggingGrepHelper = (type, data, logLevel) => {
+    const d = Object.keys(data).reduce((a, b) => {
+        return [...a, `${b}=${data[b]}`];
+    }, []);
+    const msg = [`method=${type}`, ...d].join(',');
+    renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, msg);
+};
+exports.printLoggingGrepHelper = printLoggingGrepHelper;

package/dist/functions/helpers/render-has-audio-video.d.ts

@@ -0,0 +1,6 @@
+import type { CloudProvider } from '@remotion/serverless';
+import type { RenderMetadata } from '@remotion/serverless/client';
+export declare const lambdaRenderHasAudioVideo: <Provider extends CloudProvider>(renderMetadata: RenderMetadata<Provider>) => {
+    hasAudio: boolean;
+    hasVideo: boolean;
+};

package/dist/functions/helpers/render-has-audio-video.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lambdaRenderHasAudioVideo = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+const lambdaRenderHasAudioVideo = (renderMetadata) => {
+    if (renderMetadata.type === 'still') {
+        throw new Error('Cannot merge stills');
+    }
+    const support = pure_1.NoReactAPIs.codecSupportsMedia(renderMetadata.codec);
+    const hasVideo = renderMetadata
+        ? !pure_1.NoReactAPIs.isAudioCodec(renderMetadata.codec)
+        : false;
+    const hasAudio = renderMetadata
+        ? !renderMetadata.muted && support.audio
+        : false;
+    return {
+        hasAudio,
+        hasVideo,
+    };
+};
+exports.lambdaRenderHasAudioVideo = lambdaRenderHasAudioVideo;

package/dist/functions/helpers/request-context.d.ts

@@ -0,0 +1,5 @@
+export type RequestContext = {
+    invokedFunctionArn: string;
+    getRemainingTimeInMillis: () => number;
+    awsRequestId: string;
+};

package/dist/functions/helpers/request-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/functions/helpers/stream-renderer.d.ts

@@ -0,0 +1,17 @@
+import type { EmittedArtifact, LogLevel } from '@remotion/renderer';
+import type { CloudProvider } from '@remotion/serverless';
+import { type ProviderSpecifics } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
+import type { OverallProgressHelper } from './overall-render-progress';
+export declare const streamRendererFunctionWithRetry: <Provider extends CloudProvider>({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, }: {
+    payload: ServerlessPayload<Provider>;
+    functionName: string;
+    outdir: string;
+    overallProgress: OverallProgressHelper<Provider>;
+    files: string[];
+    logLevel: LogLevel;
+    onArtifact: (asset: EmittedArtifact) => {
+        alreadyExisted: boolean;
+    };
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => Promise<unknown>;