@remotion/serverless 4.0.244 → 4.0.246

package/.turbo/turbo-make.log

@@ -1,5 +1,5 @@
 
 
-> @remotion/serverless@4.0.243 make /Users/jonathanburger/remotion/packages/serverless
+> @remotion/serverless@4.0.245 make /Users/jonathanburger/remotion/packages/serverless
 > tsc -d
 

package/LICENSE.md

@@ -11,7 +11,7 @@ Depending on the type of your legal entity, you are granted permission to use Re
 
 ## Free license
 
-Copyright © 2024 [Remotion](https://www.remotion.dev)
+Copyright © 2025 [Remotion](https://www.remotion.dev)
 
 ### Eligibility
 

package/dist/best-frames-per-function-param.d.ts

@@ -0,0 +1 @@
+export declare const bestFramesPerFunctionParam: (frameCount: number) => number;

package/dist/best-frames-per-function-param.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bestFramesPerFunctionParam = void 0;
+const no_react_1 = require("remotion/no-react");
+// Always update the code in docs/lambda/concurrency.md too
+const bestFramesPerFunctionParam = (frameCount) => {
+    // Between 0 and 10 minutes (at 30fps), interpolate the concurrency from 75 to 150
+    const concurrency = (0, no_react_1.interpolate)(frameCount, [0, 18000], [75, 150], {
+        extrapolateRight: 'clamp',
+    });
+    // At least have 20 as a `framesPerFunction` value
+    const framesPerFunction = Math.max(frameCount / concurrency, 20);
+    // Evenly distribute: For 21 frames over 2 functions, distribute as 11 + 10 ==> framesPerLambda = 11
+    const functionsNeeded = Math.ceil(frameCount / framesPerFunction);
+    return Math.ceil(frameCount / functionsNeeded);
+};
+exports.bestFramesPerFunctionParam = bestFramesPerFunctionParam;

package/dist/calculate-chunk-times.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedTiming } from './types';
+export declare const calculateChunkTimes: ({ type, timings, }: {
+    type: "combined-time-for-cost-calculation" | "absolute-time";
+    timings: ParsedTiming[];
+}) => number;

package/dist/calculate-chunk-times.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateChunkTimes = void 0;
+const min_max_1 = require("./min-max");
+const getAbsoluteTime = (parsedTimings) => {
+    if (parsedTimings.length === 0) {
+        return 0;
+    }
+    const allEnds = parsedTimings.map((p) => p.rendered);
+    const allStarts = parsedTimings.map((p) => p.start);
+    const biggestEnd = (0, min_max_1.max)(allEnds);
+    const smallestStart = (0, min_max_1.min)(allStarts);
+    return Math.max(0, biggestEnd - smallestStart);
+};
+const calculateChunkTimes = ({ type, timings, }) => {
+    const parsedTimings = timings;
+    const absoluteTime = getAbsoluteTime(parsedTimings);
+    if (type === 'combined-time-for-cost-calculation') {
+        const totalEncodingTimings = parsedTimings
+            .map((p) => Math.max(0, p.rendered - p.start))
+            .reduce((a, b) => a + b, 0);
+        return totalEncodingTimings + absoluteTime;
+    }
+    if (type === 'absolute-time') {
+        return absoluteTime;
+    }
+    throw new Error('invalid time for calculate chunk times');
+};
+exports.calculateChunkTimes = calculateChunkTimes;

package/dist/can-concat-seamlessly.d.ts

@@ -0,0 +1,3 @@
+import type { AudioCodec, Codec } from '@remotion/renderer';
+export declare const canConcatAudioSeamlessly: (audioCodec: AudioCodec | null, chunkDurationInFrames: number) => boolean;
+export declare const canConcatVideoSeamlessly: (codec: Codec) => codec is "h264";

package/dist/can-concat-seamlessly.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canConcatVideoSeamlessly = exports.canConcatAudioSeamlessly = void 0;
+// Cannot do WAV yet, because currently assumes AAC in+outpoint
+const canConcatAudioSeamlessly = (audioCodec, chunkDurationInFrames) => {
+    // Rendering a chunk that is too small generates too much overhead
+    // and is currently buggy
+    if (chunkDurationInFrames <= 4) {
+        return false;
+    }
+    return audioCodec === 'aac';
+};
+exports.canConcatAudioSeamlessly = canConcatAudioSeamlessly;
+const canConcatVideoSeamlessly = (codec) => {
+    return codec === 'h264';
+};
+exports.canConcatVideoSeamlessly = canConcatVideoSeamlessly;

package/dist/cleanup-props.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedInputProps } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './types';
+export declare const cleanupProps: <Provider extends CloudProvider>({ serializedResolvedProps, inputProps, providerSpecifics, forcePathStyle, }: {
+    serializedResolvedProps: SerializedInputProps;
+    inputProps: SerializedInputProps;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<[number, number]>;

package/dist/cleanup-props.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupProps = void 0;
+const cleanup_serialized_input_props_1 = require("./cleanup-serialized-input-props");
+const cleanupProps = ({ serializedResolvedProps, inputProps, providerSpecifics, forcePathStyle, }) => {
+    const cleanupSerializedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        serialized: inputProps,
+        providerSpecifics,
+        forcePathStyle,
+    });
+    const cleanupResolvedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedResolvedProps)({
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        serialized: serializedResolvedProps,
+        providerSpecifics,
+        forcePathStyle,
+    });
+    return Promise.all([
+        cleanupSerializedInputPropsProm,
+        cleanupResolvedInputPropsProm,
+    ]);
+};
+exports.cleanupProps = cleanupProps;

package/dist/cleanup-serialized-input-props.d.ts

@@ -0,0 +1,15 @@
+import type { SerializedInputProps } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './types';
+export declare const cleanupSerializedInputProps: <Provider extends CloudProvider>({ serialized, region, providerSpecifics, forcePathStyle, }: {
+    serialized: SerializedInputProps;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<number>;
+export declare const cleanupSerializedResolvedProps: <Provider extends CloudProvider>({ serialized, region, providerSpecifics, forcePathStyle, }: {
+    serialized: SerializedInputProps;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<number>;

package/dist/cleanup-serialized-input-props.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupSerializedResolvedProps = exports.cleanupSerializedInputProps = void 0;
+const input_props_keys_1 = require("./input-props-keys");
+const cleanupSerializedInputProps = async ({ serialized, region, providerSpecifics, forcePathStyle, }) => {
+    if (serialized.type === 'payload') {
+        return 0;
+    }
+    const time = Date.now();
+    await providerSpecifics.deleteFile({
+        bucketName: serialized.bucketName,
+        key: (0, input_props_keys_1.inputPropsKey)(serialized.hash),
+        region,
+        customCredentials: null,
+        forcePathStyle,
+    });
+    return Date.now() - time;
+};
+exports.cleanupSerializedInputProps = cleanupSerializedInputProps;
+const cleanupSerializedResolvedProps = async ({ serialized, region, providerSpecifics, forcePathStyle, }) => {
+    if (serialized.type === 'payload') {
+        return 0;
+    }
+    const time = Date.now();
+    await providerSpecifics.deleteFile({
+        bucketName: serialized.bucketName,
+        key: (0, input_props_keys_1.resolvedPropsKey)(serialized.hash),
+        region,
+        customCredentials: null,
+        forcePathStyle,
+    });
+    return Date.now() - time;
+};
+exports.cleanupSerializedResolvedProps = cleanupSerializedResolvedProps;

package/dist/client.d.ts

@@ -1,15 +1,24 @@
+export { COMMAND_NOT_FOUND } from './constants';
 export { Await } from './await';
 export { compressInputProps, decompressInputProps, getNeedsToUpload, serializeOrThrow, } from './compress-props';
 export { REMOTION_BUCKET_PREFIX, ServerlessCodec, ServerlessPayload, ServerlessPayloads, ServerlessRoutines, ServerlessStartPayload, ServerlessStatusPayload, artifactName, customOutName, expiryDays, outName, outStillName, overallProgressKey, rendersPrefix, serverlessCodecs, type CustomCredentials, type CustomCredentialsWithoutSensitiveData, type DeleteAfter, type DownloadBehavior, type OutNameInput, type OutNameInputWithoutCredentials, type OutNameOutput, type Privacy, type SerializedInputProps, type WebhookOption, } from './constants';
 export { GetOrCreateBucketInput, GetOrCreateBucketOutput, internalGetOrCreateBucket, } from './get-or-create-bucket';
+export { validateDownloadBehavior } from './validate-download-behavior';
+export { validateFramesPerFunction } from './validate-frames-per-function';
 export { errorIsOutOfSpaceError, isBrowserCrashedError, isErrInsufficientResourcesErr, } from './error-category';
+export { calculateChunkTimes } from './calculate-chunk-times';
+export { MAX_FUNCTIONS_PER_RENDER } from './constants';
+export { DOCS_URL } from './docs-url';
 export { getExpectedOutName } from './expected-out-name';
 export { FileNameAndSize, GetFolderFiles } from './get-files-in-folder';
+export { getOverallProgressFromStorage } from './get-overall-progress-from-storage';
 export { inputPropsKey, resolvedPropsKey } from './input-props-keys';
 export { makeBucketName } from './make-bucket-name';
+export { getProgress } from './progress';
 export { RenderMetadata } from './render-metadata';
 export { streamToString } from './stream-to-string';
 export { MessageTypeId, formatMap, makeStreamPayload, messageTypeIdToMessageType, } from './streaming/streaming';
 export { truthy } from './truthy';
 export { validateBucketName } from './validate-bucket-name';
+export { validatePrivacy } from './validate-privacy';
 export { validateWebhook } from './validate-webhook';

package/dist/client.js

@@ -1,35 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateWebhook = exports.validateBucketName = exports.truthy = exports.messageTypeIdToMessageType = exports.makeStreamPayload = exports.formatMap = exports.streamToString = exports.makeBucketName = exports.resolvedPropsKey = exports.inputPropsKey = exports.getExpectedOutName = exports.isErrInsufficientResourcesErr = exports.isBrowserCrashedError = exports.errorIsOutOfSpaceError = exports.internalGetOrCreateBucket = exports.serverlessCodecs = exports.rendersPrefix = exports.overallProgressKey = exports.outStillName = exports.outName = exports.expiryDays = exports.customOutName = exports.artifactName = exports.ServerlessRoutines = exports.REMOTION_BUCKET_PREFIX = exports.serializeOrThrow = exports.getNeedsToUpload = exports.decompressInputProps = exports.compressInputProps = void 0;
+exports.validateWebhook = exports.validatePrivacy = exports.validateBucketName = exports.truthy = exports.messageTypeIdToMessageType = exports.makeStreamPayload = exports.formatMap = exports.streamToString = exports.getProgress = exports.makeBucketName = exports.resolvedPropsKey = exports.inputPropsKey = exports.getOverallProgressFromStorage = exports.getExpectedOutName = exports.DOCS_URL = exports.MAX_FUNCTIONS_PER_RENDER = exports.calculateChunkTimes = exports.isErrInsufficientResourcesErr = exports.isBrowserCrashedError = exports.errorIsOutOfSpaceError = exports.validateFramesPerFunction = exports.validateDownloadBehavior = exports.internalGetOrCreateBucket = exports.serverlessCodecs = exports.rendersPrefix = exports.overallProgressKey = exports.outStillName = exports.outName = exports.expiryDays = exports.customOutName = exports.artifactName = exports.ServerlessRoutines = exports.REMOTION_BUCKET_PREFIX = exports.serializeOrThrow = exports.getNeedsToUpload = exports.decompressInputProps = exports.compressInputProps = exports.COMMAND_NOT_FOUND = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "COMMAND_NOT_FOUND", { enumerable: true, get: function () { return constants_1.COMMAND_NOT_FOUND; } });
 var compress_props_1 = require("./compress-props");
 Object.defineProperty(exports, "compressInputProps", { enumerable: true, get: function () { return compress_props_1.compressInputProps; } });
 Object.defineProperty(exports, "decompressInputProps", { enumerable: true, get: function () { return compress_props_1.decompressInputProps; } });
 Object.defineProperty(exports, "getNeedsToUpload", { enumerable: true, get: function () { return compress_props_1.getNeedsToUpload; } });
 Object.defineProperty(exports, "serializeOrThrow", { enumerable: true, get: function () { return compress_props_1.serializeOrThrow; } });
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "REMOTION_BUCKET_PREFIX", { enumerable: true, get: function () { return constants_1.REMOTION_BUCKET_PREFIX; } });
-Object.defineProperty(exports, "ServerlessRoutines", { enumerable: true, get: function () { return constants_1.ServerlessRoutines; } });
-Object.defineProperty(exports, "artifactName", { enumerable: true, get: function () { return constants_1.artifactName; } });
-Object.defineProperty(exports, "customOutName", { enumerable: true, get: function () { return constants_1.customOutName; } });
-Object.defineProperty(exports, "expiryDays", { enumerable: true, get: function () { return constants_1.expiryDays; } });
-Object.defineProperty(exports, "outName", { enumerable: true, get: function () { return constants_1.outName; } });
-Object.defineProperty(exports, "outStillName", { enumerable: true, get: function () { return constants_1.outStillName; } });
-Object.defineProperty(exports, "overallProgressKey", { enumerable: true, get: function () { return constants_1.overallProgressKey; } });
-Object.defineProperty(exports, "rendersPrefix", { enumerable: true, get: function () { return constants_1.rendersPrefix; } });
-Object.defineProperty(exports, "serverlessCodecs", { enumerable: true, get: function () { return constants_1.serverlessCodecs; } });
+var constants_2 = require("./constants");
+Object.defineProperty(exports, "REMOTION_BUCKET_PREFIX", { enumerable: true, get: function () { return constants_2.REMOTION_BUCKET_PREFIX; } });
+Object.defineProperty(exports, "ServerlessRoutines", { enumerable: true, get: function () { return constants_2.ServerlessRoutines; } });
+Object.defineProperty(exports, "artifactName", { enumerable: true, get: function () { return constants_2.artifactName; } });
+Object.defineProperty(exports, "customOutName", { enumerable: true, get: function () { return constants_2.customOutName; } });
+Object.defineProperty(exports, "expiryDays", { enumerable: true, get: function () { return constants_2.expiryDays; } });
+Object.defineProperty(exports, "outName", { enumerable: true, get: function () { return constants_2.outName; } });
+Object.defineProperty(exports, "outStillName", { enumerable: true, get: function () { return constants_2.outStillName; } });
+Object.defineProperty(exports, "overallProgressKey", { enumerable: true, get: function () { return constants_2.overallProgressKey; } });
+Object.defineProperty(exports, "rendersPrefix", { enumerable: true, get: function () { return constants_2.rendersPrefix; } });
+Object.defineProperty(exports, "serverlessCodecs", { enumerable: true, get: function () { return constants_2.serverlessCodecs; } });
 var get_or_create_bucket_1 = require("./get-or-create-bucket");
 Object.defineProperty(exports, "internalGetOrCreateBucket", { enumerable: true, get: function () { return get_or_create_bucket_1.internalGetOrCreateBucket; } });
+var validate_download_behavior_1 = require("./validate-download-behavior");
+Object.defineProperty(exports, "validateDownloadBehavior", { enumerable: true, get: function () { return validate_download_behavior_1.validateDownloadBehavior; } });
+var validate_frames_per_function_1 = require("./validate-frames-per-function");
+Object.defineProperty(exports, "validateFramesPerFunction", { enumerable: true, get: function () { return validate_frames_per_function_1.validateFramesPerFunction; } });
 var error_category_1 = require("./error-category");
 Object.defineProperty(exports, "errorIsOutOfSpaceError", { enumerable: true, get: function () { return error_category_1.errorIsOutOfSpaceError; } });
 Object.defineProperty(exports, "isBrowserCrashedError", { enumerable: true, get: function () { return error_category_1.isBrowserCrashedError; } });
 Object.defineProperty(exports, "isErrInsufficientResourcesErr", { enumerable: true, get: function () { return error_category_1.isErrInsufficientResourcesErr; } });
+var calculate_chunk_times_1 = require("./calculate-chunk-times");
+Object.defineProperty(exports, "calculateChunkTimes", { enumerable: true, get: function () { return calculate_chunk_times_1.calculateChunkTimes; } });
+var constants_3 = require("./constants");
+Object.defineProperty(exports, "MAX_FUNCTIONS_PER_RENDER", { enumerable: true, get: function () { return constants_3.MAX_FUNCTIONS_PER_RENDER; } });
+var docs_url_1 = require("./docs-url");
+Object.defineProperty(exports, "DOCS_URL", { enumerable: true, get: function () { return docs_url_1.DOCS_URL; } });
 var expected_out_name_1 = require("./expected-out-name");
 Object.defineProperty(exports, "getExpectedOutName", { enumerable: true, get: function () { return expected_out_name_1.getExpectedOutName; } });
+var get_overall_progress_from_storage_1 = require("./get-overall-progress-from-storage");
+Object.defineProperty(exports, "getOverallProgressFromStorage", { enumerable: true, get: function () { return get_overall_progress_from_storage_1.getOverallProgressFromStorage; } });
 var input_props_keys_1 = require("./input-props-keys");
 Object.defineProperty(exports, "inputPropsKey", { enumerable: true, get: function () { return input_props_keys_1.inputPropsKey; } });
 Object.defineProperty(exports, "resolvedPropsKey", { enumerable: true, get: function () { return input_props_keys_1.resolvedPropsKey; } });
 var make_bucket_name_1 = require("./make-bucket-name");
 Object.defineProperty(exports, "makeBucketName", { enumerable: true, get: function () { return make_bucket_name_1.makeBucketName; } });
+var progress_1 = require("./progress");
+Object.defineProperty(exports, "getProgress", { enumerable: true, get: function () { return progress_1.getProgress; } });
 var stream_to_string_1 = require("./stream-to-string");
 Object.defineProperty(exports, "streamToString", { enumerable: true, get: function () { return stream_to_string_1.streamToString; } });
 var streaming_1 = require("./streaming/streaming");
@@ -40,5 +56,7 @@ var truthy_1 = require("./truthy");
 Object.defineProperty(exports, "truthy", { enumerable: true, get: function () { return truthy_1.truthy; } });
 var validate_bucket_name_1 = require("./validate-bucket-name");
 Object.defineProperty(exports, "validateBucketName", { enumerable: true, get: function () { return validate_bucket_name_1.validateBucketName; } });
+var validate_privacy_1 = require("./validate-privacy");
+Object.defineProperty(exports, "validatePrivacy", { enumerable: true, get: function () { return validate_privacy_1.validatePrivacy; } });
 var validate_webhook_1 = require("./validate-webhook");
 Object.defineProperty(exports, "validateWebhook", { enumerable: true, get: function () { return validate_webhook_1.validateWebhook; } });

package/dist/compress-props.d.ts

@@ -1,9 +1,13 @@
 import type { SerializedInputProps } from './constants';
 import type { ProviderSpecifics } from './provider-implementation';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 type PropsType = 'input-props' | 'resolved-props';
 export declare const serializeOrThrow: (inputProps: Record<string, unknown>, propsType: PropsType) => string;
-export declare const getNeedsToUpload: (type: "still" | "video-or-audio", sizes: number[]) => boolean;
+export declare const getNeedsToUpload: <Provider extends CloudProvider>({ type, sizes, providerSpecifics, }: {
+    type: "still" | "video-or-audio";
+    sizes: number[];
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => boolean;
 export declare const compressInputProps: <Provider extends CloudProvider>({ stringifiedInputProps, region, userSpecifiedBucketName, propsType, needsToUpload, providerSpecifics, forcePathStyle, skipPutAcl, }: {
     stringifiedInputProps: string;
     region: Provider["region"];

package/dist/compress-props.js

@@ -26,13 +26,15 @@ const serializeOrThrow = (inputProps, propsType) => {
     }
 };
 exports.serializeOrThrow = serializeOrThrow;
-const getNeedsToUpload = (type, sizes) => {
+const getNeedsToUpload = ({ type, sizes, providerSpecifics, }) => {
     const MARGIN = 5000 + validate_webhook_1.MAX_WEBHOOK_CUSTOM_DATA_SIZE;
-    const MAX_INLINE_PAYLOAD_SIZE = (type === 'still' ? 5000000 : 200000) - MARGIN;
+    const MAX_INLINE_PAYLOAD_SIZE = (type === 'still'
+        ? providerSpecifics.getMaxStillInlinePayloadSize()
+        : providerSpecifics.getMaxNonInlinePayloadSizePerFunction()) - MARGIN;
     const sizesAlreadyUsed = sizes.reduce((a, b) => a + b);
     if (sizesAlreadyUsed > MAX_INLINE_PAYLOAD_SIZE) {
         // eslint-disable-next-line no-console
-        console.warn(`Warning: The props are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(sizesAlreadyUsed / 1024)}KB) in size. Uploading them to S3 to circumvent AWS Lambda payload size, which may lead to slowdown.`);
+        console.warn(`Warning: The props are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(sizesAlreadyUsed / 1024)}KB) in size. Uploading them to ${providerSpecifics.serverStorageProductName()} to circumvent AWS Lambda payload size, which may lead to slowdown.`);
         return true;
     }
     return false;

package/dist/concat-videos.d.ts

@@ -0,0 +1,25 @@
+import type { AudioCodec, CancelSignal, LogLevel } from '@remotion/renderer';
+import { type ServerlessCodec } from './constants';
+import type { InsideFunctionSpecifics } from './provider-implementation';
+export declare const concatVideos: ({ onProgress, numberOfFrames, codec, fps, numberOfGifLoops, files, outdir, audioCodec, audioBitrate, logLevel, framesPerLambda, binariesDirectory, cancelSignal, preferLossless, muted, metadata, insideFunctionSpecifics, }: {
+    onProgress: (frames: number) => void;
+    numberOfFrames: number;
+    codec: ServerlessCodec;
+    fps: number;
+    numberOfGifLoops: number | null;
+    files: string[];
+    outdir: string;
+    audioCodec: AudioCodec | null;
+    audioBitrate: string | null;
+    logLevel: LogLevel;
+    framesPerLambda: number;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    preferLossless: boolean;
+    muted: boolean;
+    metadata: Record<string, string> | null;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+}) => Promise<{
+    outfile: string;
+    cleanupChunksProm: Promise<void>;
+}>;

package/dist/concat-videos.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatVideos = void 0;
+const renderer_1 = require("@remotion/renderer");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = require("node:path");
+const can_concat_seamlessly_1 = require("./can-concat-seamlessly");
+const constants_1 = require("./constants");
+const concatVideos = async ({ onProgress, numberOfFrames, codec, fps, numberOfGifLoops, files, outdir, audioCodec, audioBitrate, logLevel, framesPerLambda, binariesDirectory, cancelSignal, preferLossless, muted, metadata, insideFunctionSpecifics, }) => {
+    const outfile = (0, node_path_1.join)(renderer_1.RenderInternals.tmpDir(constants_1.REMOTION_CONCATED_TOKEN), `concat.${renderer_1.RenderInternals.getFileExtensionFromCodec(codec, audioCodec)}`);
+    const combine = insideFunctionSpecifics.timer('Combine chunks', logLevel);
+    const filelistDir = renderer_1.RenderInternals.tmpDir(constants_1.REMOTION_FILELIST_TOKEN);
+    const chunkDurationInSeconds = framesPerLambda / fps;
+    const resolvedAudioCodec = renderer_1.RenderInternals.resolveAudioCodec({
+        setting: audioCodec,
+        codec,
+        preferLossless,
+        separateAudioTo: null,
+    });
+    const seamlessAudio = (0, can_concat_seamlessly_1.canConcatAudioSeamlessly)(resolvedAudioCodec, framesPerLambda);
+    const seamlessVideo = (0, can_concat_seamlessly_1.canConcatVideoSeamlessly)(codec);
+    await renderer_1.RenderInternals.combineChunks({
+        files,
+        filelistDir,
+        output: outfile,
+        onProgress,
+        numberOfFrames,
+        codec,
+        fps,
+        numberOfGifLoops,
+        resolvedAudioCodec,
+        audioBitrate,
+        indent: false,
+        logLevel,
+        chunkDurationInSeconds,
+        binariesDirectory,
+        cancelSignal,
+        seamlessAudio,
+        seamlessVideo,
+        muted,
+        metadata,
+    });
+    combine.end();
+    const cleanupChunksProm = node_fs_1.default.promises.rm(outdir, {
+        recursive: true,
+        force: true,
+    });
+    return { outfile, cleanupChunksProm };
+};
+exports.concatVideos = concatVideos;

package/dist/constants.d.ts

@@ -1,6 +1,8 @@
 import type { AudioCodec, ChromiumOptions, ColorSpace, FrameRange, LogLevel, PixelFormat, ProResProfile, StillImageFormat, ToOptions, VideoImageFormat, X264Preset } from '@remotion/renderer';
 import type { BrowserSafeApis } from '@remotion/renderer/client';
-import type { CloudProvider } from './still';
+import type { ExpensiveChunk } from './most-expensive-chunks';
+import type { ChunkRetry, CloudProvider, ReceivedArtifact } from './types';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
 export declare const expiryDays: {
     readonly '1-day': 1;
     readonly '3-days': 3;
@@ -122,7 +124,7 @@ export type ServerlessPayloads<Provider extends CloudProvider> = {
         type: ServerlessRoutines.launch;
         serveUrl: string;
         composition: string;
-        framesPerLambda: number | null;
+        framesPerFunction: number | null;
         bucketName: string;
         inputProps: SerializedInputProps;
         renderId: string;
@@ -145,7 +147,7 @@ export type ServerlessPayloads<Provider extends CloudProvider> = {
         scale: number;
         everyNthFrame: number;
         numberOfGifLoops: number | null;
-        concurrencyPerLambda: number;
+        concurrencyPerFunction: number;
         downloadBehavior: DownloadBehavior;
         muted: boolean;
         overwrite: boolean;
@@ -272,4 +274,38 @@ export declare const outName: (renderId: string, extension: string) => string;
 export declare const customOutName: <Provider extends CloudProvider>(renderId: string, bucketName: string, name: OutNameInput<Provider>) => OutNameOutput<Provider>;
 export declare const overallProgressKey: (renderId: string) => string;
 export declare const artifactName: (renderId: string, name: string) => string;
+export type PostRenderData<Provider extends CloudProvider> = {
+    cost: AfterRenderCost;
+    outputFile: string;
+    outputSize: number;
+    renderSize: number;
+    timeToFinish: number;
+    timeToRenderFrames: number;
+    errors: EnhancedErrorInfo[];
+    startTime: number;
+    endTime: number;
+    filesCleanedUp: number;
+    timeToEncode: number;
+    timeToCleanUp: number;
+    timeToRenderChunks: number;
+    retriesInfo: ChunkRetry[];
+    mostExpensiveFrameRanges: ExpensiveChunk[] | undefined;
+    estimatedBillingDurationInMilliseconds: number;
+    deleteAfter: DeleteAfter | null;
+    timeToCombine: number | null;
+    artifactProgress: ReceivedArtifact<Provider>[];
+};
+export type AfterRenderCost = {
+    estimatedCost: number;
+    estimatedDisplayCost: string;
+    currency: string;
+    disclaimer: string;
+};
+export declare const CONCAT_FOLDER_TOKEN = "remotion-concat";
+export declare const MAX_FUNCTIONS_PER_RENDER = 200;
+export declare const MINIMUM_FRAMES_PER_LAMBDA = 4;
+export declare const REMOTION_CONCATED_TOKEN = "remotion-concated-token";
+export declare const REMOTION_FILELIST_TOKEN = "remotion-filelist";
+export declare const RENDERER_PATH_TOKEN = "remotion-bucket";
+export declare const COMMAND_NOT_FOUND = "Command not found";
 export {};

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.artifactName = exports.overallProgressKey = exports.customOutName = exports.outName = exports.outStillName = exports.rendersPrefix = exports.REMOTION_BUCKET_PREFIX = exports.serverlessCodecs = exports.ServerlessRoutines = exports.expiryDays = void 0;
+exports.COMMAND_NOT_FOUND = exports.RENDERER_PATH_TOKEN = exports.REMOTION_FILELIST_TOKEN = exports.REMOTION_CONCATED_TOKEN = exports.MINIMUM_FRAMES_PER_LAMBDA = exports.MAX_FUNCTIONS_PER_RENDER = exports.CONCAT_FOLDER_TOKEN = exports.artifactName = exports.overallProgressKey = exports.customOutName = exports.outName = exports.outStillName = exports.rendersPrefix = exports.REMOTION_BUCKET_PREFIX = exports.serverlessCodecs = exports.ServerlessRoutines = exports.expiryDays = void 0;
 // Needs to be in sync with renderer/src/options/delete-after.ts#L7
 exports.expiryDays = {
     '1-day': 1,
@@ -56,3 +56,10 @@ const overallProgressKey = (renderId) => `${(0, exports.rendersPrefix)(renderId)
 exports.overallProgressKey = overallProgressKey;
 const artifactName = (renderId, name) => `${(0, exports.rendersPrefix)(renderId)}/artifacts/${name}`;
 exports.artifactName = artifactName;
+exports.CONCAT_FOLDER_TOKEN = 'remotion-concat';
+exports.MAX_FUNCTIONS_PER_RENDER = 200;
+exports.MINIMUM_FRAMES_PER_LAMBDA = 4;
+exports.REMOTION_CONCATED_TOKEN = 'remotion-concated-token';
+exports.REMOTION_FILELIST_TOKEN = 'remotion-filelist';
+exports.RENDERER_PATH_TOKEN = 'remotion-bucket';
+exports.COMMAND_NOT_FOUND = 'Command not found';

package/dist/create-post-render-data.d.ts

@@ -0,0 +1,20 @@
+import type { PostRenderData } from './constants';
+import type { OutputFileMetadata } from './find-output-file-in-bucket';
+import type { OverallRenderProgress } from './overall-render-progress';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
+export declare const createPostRenderData: <Provider extends CloudProvider>({ region, memorySizeInMb, renderMetadata, errorExplanations, timeToDelete, outputFile, timeToCombine, overallProgress, timeToFinish, outputSize, providerSpecifics, }: {
+    region: Provider["region"];
+    memorySizeInMb: number;
+    renderMetadata: RenderMetadata<Provider>;
+    timeToDelete: number;
+    errorExplanations: EnhancedErrorInfo[];
+    outputFile: OutputFileMetadata;
+    timeToCombine: number | null;
+    overallProgress: OverallRenderProgress<Provider>;
+    timeToFinish: number;
+    outputSize: number;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => PostRenderData<Provider>;

package/dist/create-post-render-data.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostRenderData = void 0;
+const calculate_chunk_times_1 = require("./calculate-chunk-times");
+const most_expensive_chunks_1 = require("./most-expensive-chunks");
+const createPostRenderData = ({ region, memorySizeInMb, renderMetadata, errorExplanations, timeToDelete, outputFile, timeToCombine, overallProgress, timeToFinish, outputSize, providerSpecifics, }) => {
+    const parsedTimings = overallProgress.timings;
+    const estimatedBillingDurationInMilliseconds = parsedTimings
+        .map((p) => p.rendered - p.start + most_expensive_chunks_1.OVERHEAD_TIME_PER_LAMBDA)
+        .reduce((a, b) => a + b);
+    const cost = providerSpecifics.estimatePrice({
+        durationInMilliseconds: estimatedBillingDurationInMilliseconds,
+        memorySizeInMb,
+        region,
+        lambdasInvoked: renderMetadata.estimatedTotalLambdaInvokations,
+        diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+    });
+    if (!outputFile) {
+        throw new Error('Cannot wrap up without an output file in the S3 bucket.');
+    }
+    const endTime = Date.now();
+    if (overallProgress.timeToEncode === null) {
+        throw new Error('Expected time to encode to be set');
+    }
+    if (overallProgress.timeToRenderFrames === null) {
+        throw new Error('Expected time to encode to be set');
+    }
+    return {
+        cost: {
+            currency: 'USD',
+            disclaimer: 'Estimated cost for function invocations only. Does not include cost for storage and data transfer.',
+            estimatedCost: cost,
+            estimatedDisplayCost: `$${new Intl.NumberFormat('en-US', {
+                currency: 'USD',
+                currencyDisplay: 'narrowSymbol',
+            }).format(cost)}`,
+        },
+        outputFile: outputFile.url,
+        timeToFinish,
+        errors: errorExplanations,
+        startTime: renderMetadata.startedDate,
+        endTime,
+        outputSize,
+        renderSize: outputSize,
+        filesCleanedUp: 0,
+        timeToEncode: overallProgress.timeToEncode,
+        timeToCleanUp: timeToDelete,
+        timeToRenderChunks: (0, calculate_chunk_times_1.calculateChunkTimes)({
+            type: 'absolute-time',
+            timings: overallProgress.timings,
+        }),
+        timeToRenderFrames: overallProgress.timeToRenderFrames,
+        retriesInfo: overallProgress.retries,
+        mostExpensiveFrameRanges: renderMetadata.type === 'still'
+            ? []
+            : (0, most_expensive_chunks_1.getMostExpensiveChunks)({
+                parsedTimings,
+                framesPerFunction: renderMetadata.framesPerLambda,
+                firstFrame: renderMetadata.frameRange[0],
+                lastFrame: renderMetadata.frameRange[1],
+            }),
+        deleteAfter: renderMetadata.deleteAfter,
+        estimatedBillingDurationInMilliseconds,
+        timeToCombine: timeToCombine !== null && timeToCombine !== void 0 ? timeToCombine : null,
+        artifactProgress: overallProgress.receivedArtifact,
+    };
+};
+exports.createPostRenderData = createPostRenderData;

package/dist/docs-url.d.ts

@@ -0,0 +1 @@
+export declare const DOCS_URL = "https://remotion.dev";

package/dist/docs-url.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCS_URL = void 0;
+exports.DOCS_URL = 'https://remotion.dev';

package/dist/estimate-price-from-bucket.d.ts

@@ -0,0 +1,15 @@
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider, ParsedTiming } from './types';
+export declare const estimatePriceFromMetadata: <Provider extends CloudProvider>({ renderMetadata, memorySizeInMb, diskSizeInMb, functionsInvoked, timings, region, providerSpecifics, }: {
+    renderMetadata: RenderMetadata<Provider> | null;
+    memorySizeInMb: number;
+    diskSizeInMb: number;
+    functionsInvoked: number;
+    timings: ParsedTiming[];
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => {
+    accruedSoFar: number;
+    estimatedBillingDurationInMilliseconds: number;
+} | null;