@remotion/serverless 4.0.244 → 4.0.246

package/dist/merge-chunks.d.ts

@@ -0,0 +1,38 @@
+import type { AudioCodec, LogLevel } from '@remotion/renderer';
+import type { CustomCredentials, DownloadBehavior, PostRenderData, Privacy, SerializedInputProps, ServerlessCodec } from './constants';
+import type { OverallProgressHelper } from './overall-render-progress';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+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>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+    forcePathStyle: boolean;
+}) => Promise<PostRenderData<Provider>>;

package/dist/merge-chunks.js

@@ -0,0 +1,92 @@
+"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 inspect_error_1 = require("./inspect-error");
+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');
+    }
+    if (options.files.length === 0) {
+        throw new Error('No files to merge');
+    }
+    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,
+        insideFunctionSpecifics: options.insideFunctionSpecifics,
+    });
+    const encodingStop = Date.now();
+    options.overallProgress.setTimeToCombine(encodingStop - encodingStart);
+    const outputSize = fs_1.default.statSync(outfile).size;
+    const writeToBucket = options.insideFunctionSpecifics.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_error_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 } = options.providerSpecifics.getOutputUrl({
+        bucketName: options.renderBucketName,
+        currentRegion: options.providerSpecifics.getCurrentRegionInFunction(),
+        customCredentials: options.customCredentials,
+        renderMetadata: options.renderMetadata,
+    });
+    const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
+        region: options.providerSpecifics.getCurrentRegionInFunction(),
+        memorySizeInMb: options.insideFunctionSpecifics.getCurrentMemorySizeInMb(),
+        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,
+        providerSpecifics: options.providerSpecifics,
+    });
+    options.overallProgress.setPostRenderData(postRenderData);
+    await Promise.all([cleanupChunksProm, fs_1.default.promises.rm(outfile)]);
+    return postRenderData;
+};
+exports.mergeChunksAndFinishRender = mergeChunksAndFinishRender;

package/dist/min-max.d.ts

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

package/dist/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/most-expensive-chunks.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedTiming } from './types';
+export declare const OVERHEAD_TIME_PER_LAMBDA = 100;
+export type ExpensiveChunk = {
+    chunk: number;
+    frameRange: [number, number];
+    timeInMilliseconds: number;
+};
+export declare const getMostExpensiveChunks: ({ parsedTimings, framesPerFunction: framesPerLambda, firstFrame, lastFrame, }: {
+    parsedTimings: ParsedTiming[];
+    framesPerFunction: number;
+    firstFrame: number;
+    lastFrame: number;
+}) => ExpensiveChunk[];

package/dist/most-expensive-chunks.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMostExpensiveChunks = exports.OVERHEAD_TIME_PER_LAMBDA = void 0;
+exports.OVERHEAD_TIME_PER_LAMBDA = 100;
+const getMostExpensiveChunks = ({ parsedTimings, framesPerFunction: framesPerLambda, firstFrame, lastFrame, }) => {
+    const mostExpensiveChunks = parsedTimings
+        .slice(0)
+        .sort((a, b) => {
+        const durA = a.rendered - a.start;
+        const durB = b.rendered - b.start;
+        return durB - durA;
+    })
+        .slice(0, 5);
+    return mostExpensiveChunks.map((c) => {
+        const isLastChunk = c.chunk === parsedTimings.length - 1;
+        return {
+            timeInMilliseconds: c.rendered - c.start,
+            chunk: c.chunk,
+            frameRange: [
+                framesPerLambda * c.chunk + firstFrame,
+                isLastChunk
+                    ? lastFrame
+                    : framesPerLambda * (c.chunk + 1) - 1 + firstFrame,
+            ],
+        };
+    });
+};
+exports.getMostExpensiveChunks = getMostExpensiveChunks;

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

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

package/dist/on-downloads-helpers.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/overall-render-progress.d.ts

@@ -0,0 +1,59 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { PostRenderData } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { ChunkRetry, CloudProvider, ParsedTiming, ReceivedArtifact } from './types';
+import type { FunctionErrorInfo } from './write-error-to-storage';
+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: FunctionErrorInfo[];
+    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: FunctionErrorInfo) => 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/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 constants_1 = require("./constants");
+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, constants_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/plan-frame-ranges.d.ts

@@ -0,0 +1,7 @@
+export declare const planFrameRanges: ({ framesPerFunction, frameRange, everyNthFrame, }: {
+    framesPerFunction: number;
+    frameRange: [number, number];
+    everyNthFrame: number;
+}) => {
+    chunks: [number, number][];
+};

package/dist/plan-frame-ranges.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planFrameRanges = void 0;
+const renderer_1 = require("@remotion/renderer");
+const planFrameRanges = ({ framesPerFunction, frameRange, everyNthFrame, }) => {
+    const framesToRender = renderer_1.RenderInternals.getFramesToRender(frameRange, everyNthFrame);
+    const chunkCount = Math.ceil(framesToRender.length / framesPerFunction);
+    const firstFrame = frameRange[0];
+    return {
+        chunks: new Array(chunkCount).fill(1).map((_, i) => {
+            const start = i * framesPerFunction * everyNthFrame + firstFrame;
+            const end = Math.min(framesToRender[framesToRender.length - 1], (i + 1) * framesPerFunction * everyNthFrame - 1 + firstFrame);
+            return [start, end];
+        }),
+    };
+};
+exports.planFrameRanges = planFrameRanges;

package/dist/print-logging-grep-helper.d.ts

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

package/dist/print-logging-grep-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/progress.d.ts

@@ -0,0 +1,16 @@
+import type { CustomCredentials } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { GenericRenderProgress } from './render-progress';
+import type { CloudProvider } from './types';
+export declare const getProgress: <Provider extends CloudProvider>({ bucketName, renderId, expectedBucketOwner, region, memorySizeInMb, timeoutInMilliseconds, customCredentials, providerSpecifics, forcePathStyle, functionName, }: {
+    bucketName: string;
+    renderId: string;
+    expectedBucketOwner: string | null;
+    region: Provider["region"];
+    memorySizeInMb: number;
+    timeoutInMilliseconds: number;
+    customCredentials: CustomCredentials<Provider> | null;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+    functionName: string;
+}) => Promise<GenericRenderProgress<Provider>>;