@remotion/lambda 4.0.163 → 4.0.164

package/dist/api/deploy-site.d.ts

@@ -59,11 +59,11 @@ export declare const internalDeploySite: (args_0: MandatoryParameters & {
         getValue: ({ commandLine }: {
             commandLine: Record<string, unknown>;
         }) => {
-            value: "verbose" | "info" | "warn" | "error";
+            value: "error" | "verbose" | "info" | "warn";
             source: string;
         };
-        setConfig: (newLogLevel: "verbose" | "info" | "warn" | "error") => void;
-        type: "verbose" | "info" | "warn" | "error";
+        setConfig: (newLogLevel: "error" | "verbose" | "info" | "warn") => void;
+        type: "error" | "verbose" | "info" | "warn";
     };
     readonly throwIfSiteExists: {
         cliFlag: string;

package/dist/cli/args.d.ts

@@ -36,6 +36,7 @@ type LambdaCommandLineOptions = {
     [BrowserSafeApis.options.folderExpiryOption.cliFlag]: boolean | undefined;
     ['vpc-subnet-ids']: string | undefined;
     ['vpc-security-group-ids']: string | undefined;
+    ['compatible-only']: boolean;
 };
 export declare const parsedLambdaCli: LambdaCommandLineOptions & import("minimist").ParsedArgs;
 export declare const forceFlagProvided: boolean;

package/dist/cli/commands/functions/ls.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.functionsLsCommand = exports.FUNCTIONS_LS_SUBCOMMAND = void 0;
 const cli_1 = require("@remotion/cli");
 const get_functions_1 = require("../../../api/get-functions");
+const args_1 = require("../../args");
 const get_aws_region_1 = require("../../get-aws-region");
 const NAME_COLS = 70;
 const MEMORY_COLS = 15;
@@ -21,9 +22,10 @@ const functionsLsCommand = async (logLevel) => {
         indent: false,
     });
     fetchingOutput.update('Getting functions...', false);
+    const compatibleOnly = args_1.parsedLambdaCli['compatible-only'] || false;
     const functions = await (0, get_functions_1.getFunctions)({
         region,
-        compatibleOnly: false,
+        compatibleOnly,
     });
     if (cli_1.CliInternals.quietFlagProvided()) {
         if (functions.length === 0) {

package/dist/functions/helpers/get-overall-progress-s3.d.ts

@@ -0,0 +1,6 @@
+import type { OverallRenderProgress } from './overall-render-progress';
+export declare const getOverallProgressS3: ({ renderId, bucketName, expectedBucketOwner, }: {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+}) => Promise<OverallRenderProgress | null>;

package/dist/functions/helpers/get-overall-progress-s3.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOverallProgressS3 = void 0;
+const defaults_1 = require("../../defaults");
+const stream_to_string_1 = require("../../shared/stream-to-string");
+const get_current_region_1 = require("./get-current-region");
+const io_1 = require("./io");
+const getOverallProgressS3 = async ({ renderId, bucketName, expectedBucketOwner, }) => {
+    try {
+        const Body = await (0, io_1.lambdaReadFile)({
+            bucketName,
+            key: (0, defaults_1.overallProgressKey)(renderId),
+            expectedBucketOwner,
+            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        });
+        const str = await (0, stream_to_string_1.streamToString)(Body);
+        return JSON.parse(str);
+    }
+    catch (err) {
+        return null;
+    }
+};
+exports.getOverallProgressS3 = getOverallProgressS3;

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

@@ -3,12 +3,6 @@ import type { CustomCredentials } from '../../shared/aws-clients';
 import type { PostRenderData, Privacy, RenderMetadata, SerializedInputProps } from '../../shared/constants';
 import type { DownloadBehavior } from '../../shared/content-disposition-header';
 import type { LambdaCodec } from '../../shared/validate-lambda-codec';
-export type OnAllChunksAvailable = (options: {
-    inputProps: SerializedInputProps;
-    serializedResolvedProps: SerializedInputProps;
-    framesPerLambda: number;
-    compositionStart: number;
-}) => void;
 export declare const mergeChunksAndFinishRender: (options: {
     bucketName: string;
     renderId: string;
@@ -27,7 +21,6 @@ export declare const mergeChunksAndFinishRender: (options: {
     inputProps: SerializedInputProps;
     serializedResolvedProps: SerializedInputProps;
     renderMetadata: RenderMetadata;
-    onAllChunks: OnAllChunksAvailable;
     audioBitrate: string | null;
     logLevel: LogLevel;
     framesPerLambda: number;

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

@@ -94,12 +94,6 @@ const mergeChunksAndFinishRender = async (options) => {
         onErrors,
         logLevel: options.logLevel,
     });
-    options.onAllChunks({
-        inputProps: options.inputProps,
-        serializedResolvedProps: options.serializedResolvedProps,
-        framesPerLambda: options.framesPerLambda,
-        compositionStart: options.compositionStart,
-    });
     const encodingStart = Date.now();
     if (options.renderMetadata.type === 'still') {
         throw new Error('Cannot merge stills');

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

@@ -0,0 +1,27 @@
+import type { AwsRegion } from '../../client';
+export type OverallRenderProgress = {
+    chunks: number[];
+    framesRendered: number;
+    framesEncoded: number;
+    combinedFrames: number;
+    timeToCombine: number | null;
+};
+export type OverallProgressHelper = {
+    upload: () => Promise<void>;
+    finishUploading: () => void;
+    setFrames: ({ encoded, rendered, index, }: {
+        rendered: number;
+        encoded: number;
+        index: number;
+    }) => void;
+    addChunkCompleted: (chunkIndex: number) => void;
+    setCombinedFrames: (framesEncoded: number) => void;
+    setTimeToCombine: (timeToCombine: number) => void;
+};
+export declare const makeOverallRenderProgress: ({ renderId, bucketName, expectedBucketOwner, region, expectedChunks, }: {
+    renderId: string;
+    bucketName: string;
+    expectedBucketOwner: string;
+    region: AwsRegion;
+    expectedChunks: number;
+}) => OverallProgressHelper;

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOverallRenderProgress = void 0;
+const constants_1 = require("../../shared/constants");
+const io_1 = require("./io");
+const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, expectedChunks, }) => {
+    const framesRendered = new Array(expectedChunks).fill(0);
+    const framesEncoded = new Array(expectedChunks).fill(0);
+    const renderProgress = {
+        chunks: [],
+        framesRendered: 0,
+        framesEncoded: 0,
+        combinedFrames: 0,
+        timeToCombine: null,
+    };
+    let currentUploadPromise = null;
+    let lastUpload = null;
+    let stopUploading = false;
+    const finishUploading = () => {
+        stopUploading = true;
+    };
+    // TODO: What if upload fails?
+    const upload = async () => {
+        if (stopUploading) {
+            return;
+        }
+        if (lastUpload === JSON.stringify(renderProgress)) {
+            return;
+        }
+        if (currentUploadPromise) {
+            currentUploadPromise = currentUploadPromise.then(() => {
+                currentUploadPromise = null;
+                return upload();
+            });
+            return;
+        }
+        currentUploadPromise = (0, io_1.lambdaWriteFile)({
+            body: JSON.stringify(renderProgress),
+            bucketName,
+            customCredentials: null,
+            downloadBehavior: null,
+            expectedBucketOwner,
+            key: (0, constants_1.overallProgressKey)(renderId),
+            privacy: 'private',
+            region,
+        });
+        await currentUploadPromise;
+        lastUpload = JSON.stringify(renderProgress);
+        currentUploadPromise = null;
+    };
+    return {
+        upload,
+        finishUploading,
+        setFrames: ({ encoded, rendered, index, }) => {
+            framesRendered[index] = rendered;
+            framesEncoded[index] = encoded;
+            renderProgress.framesRendered = framesRendered.reduce((a, b) => a + b, 0);
+            renderProgress.framesEncoded = framesEncoded.reduce((a, b) => a + b, 0);
+            upload();
+        },
+        addChunkCompleted: (chunkIndex) => {
+            renderProgress.chunks.push(chunkIndex);
+            upload();
+        },
+        setCombinedFrames: (frames) => {
+            renderProgress.combinedFrames = frames;
+            upload();
+        },
+        setTimeToCombine: (timeToCombine) => {
+            renderProgress.timeToCombine = timeToCombine;
+            upload();
+        },
+    };
+};
+exports.makeOverallRenderProgress = makeOverallRenderProgress;

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

@@ -0,0 +1,11 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { LambdaPayload } from '../../defaults';
+import type { OverallProgressHelper } from './overall-render-progress';
+export declare const streamRendererFunctionWithRetry: ({ payload, files, functionName, outdir, overallProgress, logLevel, }: {
+    payload: LambdaPayload;
+    functionName: string;
+    outdir: string;
+    overallProgress: OverallProgressHelper;
+    files: string[];
+    logLevel: LogLevel;
+}) => Promise<unknown>;

package/dist/functions/helpers/stream-renderer.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamRendererFunctionWithRetry = void 0;
+const renderer_1 = require("@remotion/renderer");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const defaults_1 = require("../../defaults");
+const call_lambda_1 = require("../../shared/call-lambda");
+const get_current_region_1 = require("./get-current-region");
+const streamRenderer = ({ payload, functionName, outdir, overallProgress, files, logLevel, }) => {
+    if (payload.type !== defaults_1.LambdaRoutines.renderer) {
+        throw new Error('Expected renderer type');
+    }
+    return new Promise((resolve) => {
+        const receivedStreamingPayload = ({ message }) => {
+            if (message.type === 'frames-rendered') {
+                overallProgress.setFrames({
+                    index: payload.chunk,
+                    encoded: message.payload.encoded,
+                    rendered: message.payload.rendered,
+                });
+                return;
+            }
+            if (message.type === 'video-chunk-rendered') {
+                const filename = (0, path_1.join)(outdir, (0, defaults_1.chunkKeyForIndex)({
+                    index: payload.chunk,
+                    type: 'video',
+                }));
+                (0, fs_1.writeFileSync)(filename, message.payload);
+                files.push(filename);
+                return;
+            }
+            if (message.type === 'audio-chunk-rendered') {
+                const filename = (0, path_1.join)(outdir, (0, defaults_1.chunkKeyForIndex)({
+                    index: payload.chunk,
+                    type: 'audio',
+                }));
+                (0, fs_1.writeFileSync)(filename, message.payload);
+                files.push(filename);
+                return;
+            }
+            if (message.type === 'chunk-complete') {
+                overallProgress.addChunkCompleted(payload.chunk);
+                return;
+            }
+            if (message.type === 'error-occurred') {
+                overallProgress.setFrames({
+                    encoded: 0,
+                    index: payload.chunk,
+                    rendered: 0,
+                });
+                renderer_1.RenderInternals.Log.error({
+                    indent: false,
+                    logLevel,
+                }, `Renderer function of chunk ${payload.chunk} failed with error: ${message.payload.error}`);
+                renderer_1.RenderInternals.Log.error({
+                    indent: false,
+                    logLevel,
+                }, `Will retry chunk = ${message.payload.shouldRetry}`);
+                resolve({
+                    type: 'error',
+                    error: message.payload.error,
+                    shouldRetry: message.payload.shouldRetry,
+                });
+            }
+            throw new Error(`Unknown message type ${message.type}`);
+        };
+        (0, call_lambda_1.callLambdaWithStreaming)({
+            functionName,
+            payload,
+            retriesRemaining: 1,
+            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            timeoutInTest: 12000,
+            type: defaults_1.LambdaRoutines.renderer,
+            receivedStreamingPayload,
+        })
+            .then(() => {
+            resolve({
+                type: 'success',
+            });
+        })
+            .catch((err) => {
+            resolve({
+                type: 'error',
+                error: err.stack,
+                shouldRetry: false,
+            });
+        });
+    });
+};
+const streamRendererFunctionWithRetry = async ({ payload, files, functionName, outdir, overallProgress, logLevel, }) => {
+    if (payload.type !== defaults_1.LambdaRoutines.renderer) {
+        throw new Error('Expected renderer type');
+    }
+    const result = await streamRenderer({
+        files,
+        functionName,
+        outdir,
+        overallProgress,
+        payload,
+        logLevel,
+    });
+    if (result.type === 'error') {
+        if (!result.shouldRetry) {
+            throw result.error;
+        }
+        return (0, exports.streamRendererFunctionWithRetry)({
+            files,
+            functionName,
+            outdir,
+            overallProgress,
+            payload: {
+                ...payload,
+                attempt: payload.attempt + 1,
+                retriesLeft: payload.retriesLeft - 1,
+            },
+            logLevel,
+        });
+    }
+};
+exports.streamRendererFunctionWithRetry = streamRendererFunctionWithRetry;

package/dist/functions/helpers/streaming-payloads.d.ts

@@ -4,16 +4,16 @@ declare const streamingPayloadSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObje
     type: z.ZodLiteral<"render-id-determined">;
     renderId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    renderId: string;
     type: "render-id-determined";
-}, {
     renderId: string;
+}, {
     type: "render-id-determined";
+    renderId: string;
 }>]>;
 export type StreamingPayloads = z.infer<typeof streamingPayloadSchema>;
 export declare const isStreamingPayload: (str: string) => false | {
-    renderId: string;
     type: "render-id-determined";
+    renderId: string;
 };
 export declare const sendProgressEvent: (responseStream: ResponseStream, payload: StreamingPayloads) => void;
 export {};

package/dist/functions/index.js

@@ -13,7 +13,6 @@ const streamify_response_1 = require("./helpers/streamify-response");
 const streaming_payloads_1 = require("./helpers/streaming-payloads");
 const info_1 = require("./info");
 const launch_1 = require("./launch");
-const merge_1 = require("./merge");
 const progress_1 = require("./progress");
 const renderer_2 = require("./renderer");
 const start_1 = require("./start");
@@ -124,18 +123,6 @@ const innerHandler = async (params, responseStream, context) => {
         });
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.merge) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.merge, {
-            renderId: params.renderId,
-            isWarm,
-        }, params.logLevel);
-        const response = await (0, merge_1.mergeHandler)(params, {
-            expectedBucketOwner: currentUserId,
-        });
-        responseStream.write(JSON.stringify(response), () => {
-            responseStream.end();
-        });
-    }
     if (params.type === constants_1.LambdaRoutines.compositions) {
         (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.compositions, {
             isWarm,

package/dist/functions/launch.js

@@ -9,7 +9,6 @@ const aws_clients_1 = require("../shared/aws-clients");
 const compress_props_1 = require("../shared/compress-props");
 const constants_1 = require("../shared/constants");
 const docs_url_1 = require("../shared/docs-url");
-const get_aws_urls_1 = require("../shared/get-aws-urls");
 const invoke_webhook_1 = require("../shared/invoke-webhook");
 const validate_1 = require("../shared/validate");
 const validate_frames_per_lambda_1 = require("../shared/validate-frames-per-lambda");
@@ -54,7 +53,7 @@ const callFunctionWithRetry = async ({ payload, retries, functionName, }) => {
         throw err;
     }
 };
-const innerLaunchHandler = async ({ functionName, params, options, onAllChunksAvailable, }) => {
+const innerLaunchHandler = async ({ functionName, params, options, }) => {
     var _a, _b, _c, _d, _e;
     if (params.type !== constants_1.LambdaRoutines.launch) {
         throw new Error('Expected launch type');
@@ -288,7 +287,6 @@ const innerLaunchHandler = async ({ functionName, params, options, onAllChunksAv
         inputProps: params.inputProps,
         serializedResolvedProps,
         renderMetadata,
-        onAllChunks: onAllChunksAvailable,
         audioBitrate: params.audioBitrate,
         logLevel: params.logLevel,
         framesPerLambda,
@@ -303,7 +301,6 @@ const launchHandler = async (params, options) => {
     if (params.type !== constants_1.LambdaRoutines.launch) {
         throw new Error('Expected launch type');
     }
-    let allChunksAvailable = null;
     const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : process.env.AWS_LAMBDA_FUNCTION_NAME;
     const logOptions = {
         indent: false,
@@ -311,62 +308,6 @@ const launchHandler = async (params, options) => {
     };
     const onTimeout = async () => {
         var _a;
-        if (allChunksAvailable) {
-            renderer_1.RenderInternals.Log.info(logOptions, 'All chunks are available, but the function is about to time out.');
-            renderer_1.RenderInternals.Log.info(logOptions, 'Spawning another function to merge chunks.');
-            try {
-                await callFunctionWithRetry({
-                    functionName,
-                    payload: {
-                        type: constants_1.LambdaRoutines.merge,
-                        renderId: params.renderId,
-                        bucketName: params.bucketName,
-                        outName: params.outName,
-                        serializedResolvedProps: allChunksAvailable.serializedResolvedProps,
-                        inputProps: allChunksAvailable.inputProps,
-                        logLevel: params.logLevel,
-                        framesPerLambda: allChunksAvailable.framesPerLambda,
-                        preferLossless: params.preferLossless,
-                        compositionStart: allChunksAvailable.compositionStart,
-                    },
-                    retries: 2,
-                });
-                renderer_1.RenderInternals.Log.info(logOptions, `New function successfully invoked. See the CloudWatch logs for it:`);
-                renderer_1.RenderInternals.Log.info(logOptions, (0, get_aws_urls_1.getCloudwatchMethodUrl)({
-                    functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
-                    method: constants_1.LambdaRoutines.merge,
-                    region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-                    rendererFunctionName: params.rendererFunctionName,
-                    renderId: params.renderId,
-                }));
-                renderer_1.RenderInternals.Log.info(logOptions, 'This function will now time out.');
-            }
-            catch (err) {
-                if (process.env.NODE_ENV === 'test') {
-                    throw err;
-                }
-                renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to invoke additional function to merge videos:');
-                renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, err);
-                await (0, write_lambda_error_1.writeLambdaError)({
-                    bucketName: params.bucketName,
-                    errorInfo: {
-                        type: 'stitcher',
-                        message: err.message,
-                        name: err.name,
-                        stack: err.stack,
-                        tmpDir: null,
-                        frame: 0,
-                        chunk: 0,
-                        isFatal: false,
-                        attempt: 1,
-                        willRetry: false,
-                        totalAttempts: 1,
-                    },
-                    renderId: params.renderId,
-                    expectedBucketOwner: options.expectedBucketOwner,
-                });
-            }
-        }
         if (!params.webhook) {
             return;
         }
@@ -422,14 +363,6 @@ const launchHandler = async (params, options) => {
             functionName,
             params,
             options,
-            onAllChunksAvailable: ({ inputProps, serializedResolvedProps, framesPerLambda, compositionStart, }) => {
-                allChunksAvailable = {
-                    inputProps,
-                    serializedResolvedProps,
-                    framesPerLambda,
-                    compositionStart,
-                };
-            },
         });
         clearTimeout(webhookDueToTimeout);
         if (!params.webhook || webhookInvoked) {

package/dist/functions/streaming/stream-writer.d.ts

@@ -0,0 +1,6 @@
+import type { ResponseStream } from '../helpers/streamify-response';
+export type ResponseStreamWriter = {
+    write: (message: Uint8Array) => Promise<void>;
+    end: () => Promise<void>;
+};
+export declare const streamWriter: (responseStream: ResponseStream) => ResponseStreamWriter;

package/dist/functions/streaming/stream-writer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamWriter = void 0;
+// Ensures that the previous write is finished before the next one is started
+// Genius solution by ChatGPT
+const streamWriter = (responseStream) => {
+    let promiseChain = Promise.resolve();
+    const write = (message) => {
+        promiseChain = promiseChain.then(() => {
+            return new Promise((resolve, reject) => {
+                responseStream.write(message, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        });
+        return promiseChain;
+    };
+    const end = () => {
+        promiseChain = promiseChain.then(() => {
+            return new Promise((resolve) => {
+                responseStream.end(() => {
+                    resolve();
+                });
+            });
+        });
+        return promiseChain;
+    };
+    return { write, end };
+};
+exports.streamWriter = streamWriter;

package/dist/functions/streaming/streaming.d.ts

@@ -0,0 +1,79 @@
+/// <reference types="node" />
+import type { RenderStillLambdaResponsePayload } from '../still';
+declare const framesRendered: "frames-rendered";
+declare const errorOccurred: "error-occurred";
+declare const renderIdDetermined: "render-id-determined";
+declare const videoChunkRendered: "video-chunk-rendered";
+declare const audioChunkRendered: "audio-chunk-rendered";
+declare const chunkComplete: "chunk-complete";
+declare const stillRendered: "still-rendered";
+declare const messageTypes: {
+    readonly '1': {
+        readonly type: "frames-rendered";
+    };
+    readonly '2': {
+        readonly type: "error-occurred";
+    };
+    readonly '3': {
+        readonly type: "render-id-determined";
+    };
+    readonly '4': {
+        readonly type: "video-chunk-rendered";
+    };
+    readonly '5': {
+        readonly type: "audio-chunk-rendered";
+    };
+    readonly '6': {
+        readonly type: "still-rendered";
+    };
+    readonly '7': {
+        readonly type: "chunk-complete";
+    };
+};
+export type MessageTypeId = keyof typeof messageTypes;
+type MessageType = (typeof messageTypes)[MessageTypeId]['type'];
+export declare const formatMap: {
+    [key in MessageType]: 'json' | 'binary';
+};
+export type StreamingPayload = {
+    type: typeof framesRendered;
+    payload: {
+        rendered: number;
+        encoded: number;
+    };
+} | {
+    type: typeof videoChunkRendered;
+    payload: Buffer;
+} | {
+    type: typeof audioChunkRendered;
+    payload: Buffer;
+} | {
+    type: typeof errorOccurred;
+    payload: {
+        error: string;
+        shouldRetry: boolean;
+    };
+} | {
+    type: typeof renderIdDetermined;
+    payload: {
+        renderId: string;
+    };
+} | {
+    type: typeof stillRendered;
+    payload: RenderStillLambdaResponsePayload;
+} | {
+    type: typeof chunkComplete;
+    payload: {};
+};
+export declare const messageTypeIdToMessageType: (messageTypeId: MessageTypeId) => MessageType;
+export declare const messageTypeToMessageId: (messageType: MessageType) => MessageTypeId;
+export type StreamingMessage = {
+    successType: 'error' | 'success';
+    message: StreamingPayload;
+};
+export type OnMessage = (options: StreamingMessage) => void;
+export type OnStream = (payload: StreamingPayload) => void;
+export declare const makeStreamPayload: ({ message }: {
+    message: StreamingPayload;
+}) => Uint8Array;
+export {};

package/dist/functions/streaming/streaming.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStreamPayload = exports.messageTypeToMessageId = exports.messageTypeIdToMessageType = exports.formatMap = void 0;
+const client_1 = require("@remotion/renderer/client");
+const framesRendered = 'frames-rendered';
+const errorOccurred = 'error-occurred';
+const renderIdDetermined = 'render-id-determined';
+const videoChunkRendered = 'video-chunk-rendered';
+const audioChunkRendered = 'audio-chunk-rendered';
+const chunkComplete = 'chunk-complete';
+const stillRendered = 'still-rendered';
+const messageTypes = {
+    '1': { type: framesRendered },
+    '2': { type: errorOccurred },
+    '3': { type: renderIdDetermined },
+    '4': { type: videoChunkRendered },
+    '5': { type: audioChunkRendered },
+    '6': { type: stillRendered },
+    '7': { type: chunkComplete },
+};
+exports.formatMap = {
+    [framesRendered]: 'json',
+    [errorOccurred]: 'json',
+    [renderIdDetermined]: 'json',
+    [videoChunkRendered]: 'binary',
+    [audioChunkRendered]: 'binary',
+    [stillRendered]: 'json',
+    [chunkComplete]: 'json',
+};
+const messageTypeIdToMessageType = (messageTypeId) => {
+    const types = messageTypes[messageTypeId];
+    if (!types) {
+        throw new Error(`Unknown message type id ${messageTypeId}`);
+    }
+    return types.type;
+};
+exports.messageTypeIdToMessageType = messageTypeIdToMessageType;
+const messageTypeToMessageId = (messageType) => {
+    const id = Object.keys(messageTypes).find((key) => messageTypes[key].type === messageType);
+    if (!id) {
+        throw new Error(`Unknown message type ${messageType}`);
+    }
+    return id;
+};
+exports.messageTypeToMessageId = messageTypeToMessageId;
+const makeStreamPayload = ({ message }) => {
+    const body = exports.formatMap[message.type] === 'json'
+        ? Buffer.from(JSON.stringify(message.payload))
+        : message.payload;
+    return client_1.BrowserSafeApis.makeStreamPayloadMessage({
+        body,
+        nonce: (0, exports.messageTypeToMessageId)(message.type),
+        status: 0,
+    });
+};
+exports.makeStreamPayload = makeStreamPayload;

package/dist/internals.d.ts

@@ -1,5 +1,5 @@
 export declare const LambdaInternals: {
-    executeCommand: (args: string[], remotionRoot: string, logLevel: "verbose" | "info" | "warn" | "error") => Promise<void>;
+    executeCommand: (args: string[], remotionRoot: string, logLevel: "error" | "verbose" | "info" | "warn") => Promise<void>;
     makeLambdaRenderMediaPayload: ({ rendererFunctionName, frameRange, framesPerLambda, forceBucketName: bucketName, codec, composition, serveUrl, imageFormat, inputProps, region, crf, envVariables, pixelFormat, proResProfile, x264Preset, maxRetries, privacy, logLevel, outName, timeoutInMilliseconds, chromiumOptions, scale, everyNthFrame, numberOfGifLoops, audioBitrate, concurrencyPerLambda, audioCodec, forceHeight, forceWidth, webhook, videoBitrate, encodingMaxRate, encodingBufferSize, downloadBehavior, muted, overwrite, jpegQuality, offthreadVideoCacheSizeInBytes, deleteAfter, colorSpace, preferLossless, }: import("./api/make-lambda-payload").InnerRenderMediaOnLambdaInput) => Promise<import("./defaults").LambdaStartPayload>;
     getRenderProgressPayload: ({ bucketName, renderId, s3OutputProvider, logLevel, }: import(".").GetRenderProgressInput) => import("./defaults").LambdaStatusPayload;
     makeLambdaRenderStillPayload: ({ serveUrl, inputProps, imageFormat, envVariables, quality, jpegQuality, region, maxRetries, composition, privacy, frame, logLevel, outName, timeoutInMilliseconds, chromiumOptions, scale, downloadBehavior, forceHeight, forceWidth, forceBucketName, offthreadVideoCacheSizeInBytes, deleteAfter, }: import("./api/render-still-on-lambda").RenderStillOnLambdaNonNullInput) => Promise<{
@@ -14,7 +14,7 @@ export declare const LambdaInternals: {
         maxRetries: number;
         frame: number;
         privacy: import("./defaults").Privacy;
-        logLevel: "verbose" | "info" | "warn" | "error";
+        logLevel: "error" | "verbose" | "info" | "warn";
         outName: import("./defaults").OutNameInput | null;
         timeoutInMilliseconds: number;
         chromiumOptions: import("@remotion/renderer").ChromiumOptions;
@@ -56,11 +56,11 @@ export declare const LambdaInternals: {
             getValue: ({ commandLine }: {
                 commandLine: Record<string, unknown>;
             }) => {
-                value: "verbose" | "info" | "warn" | "error";
+                value: "error" | "verbose" | "info" | "warn";
                 source: string;
             };
-            setConfig: (newLogLevel: "verbose" | "info" | "warn" | "error") => void;
-            type: "verbose" | "info" | "warn" | "error";
+            setConfig: (newLogLevel: "error" | "verbose" | "info" | "warn") => void;
+            type: "error" | "verbose" | "info" | "warn";
         };
         readonly throwIfSiteExists: {
             cliFlag: string;

package/dist/shared/constants.d.ts

@@ -96,8 +96,7 @@ export declare enum LambdaRoutines {
     status = "status",
     renderer = "renderer",
     still = "still",
-    compositions = "compositions",
-    merge = "merge"
+    compositions = "compositions"
 }
 type Prettify<T> = {
     [K in keyof T]: T[K];
@@ -301,18 +300,6 @@ export type LambdaPayloads = {
         bucketName: string | null;
         offthreadVideoCacheSizeInBytes: number | null;
     };
-    merge: {
-        type: LambdaRoutines.merge;
-        bucketName: string;
-        renderId: string;
-        outName: OutNameInput | null;
-        inputProps: SerializedInputProps;
-        serializedResolvedProps: SerializedInputProps;
-        logLevel: LogLevel;
-        framesPerLambda: number;
-        preferLossless: boolean;
-        compositionStart: number;
-    };
 };
 export type LambdaPayload = LambdaPayloads[LambdaRoutines];
 export type EncodingProgress = {

package/dist/shared/constants.js

@@ -102,6 +102,5 @@ var LambdaRoutines;
     LambdaRoutines["renderer"] = "renderer";
     LambdaRoutines["still"] = "still";
     LambdaRoutines["compositions"] = "compositions";
-    LambdaRoutines["merge"] = "merge";
 })(LambdaRoutines || (exports.LambdaRoutines = LambdaRoutines = {}));
 exports.LAMBDA_CONCURRENCY_LIMIT_QUOTA = 'L-B99A9384';

package/dist/shared/return-values.d.ts

@@ -1,7 +1,6 @@
 import type { compositionsHandler } from '../functions/compositions';
 import type { infoHandler } from '../functions/info';
 import type { launchHandler } from '../functions/launch';
-import type { mergeHandler } from '../functions/merge';
 import type { progressHandler } from '../functions/progress';
 import type { rendererHandler } from '../functions/renderer';
 import type { startHandler } from '../functions/start';
@@ -20,5 +19,4 @@ export interface LambdaReturnValues {
     [LambdaRoutines.info]: ReturnType<typeof infoHandler>;
     [LambdaRoutines.still]: ReturnType<typeof stillHandler>;
     [LambdaRoutines.compositions]: ReturnType<typeof compositionsHandler>;
-    [LambdaRoutines.merge]: ReturnType<typeof mergeHandler>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/lambda",
-  "version": "4.0.163",
+  "version": "4.0.164",
   "description": "Distributed renderer for Remotion based on AWS Lambda",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -25,10 +25,10 @@
     "@aws-sdk/s3-request-presigner": "3.382.0",
     "mime-types": "2.1.34",
     "zod": "3.22.3",
-    "@remotion/bundler": "4.0.163",
-    "@remotion/renderer": "4.0.163",
-    "@remotion/cli": "4.0.163",
-    "remotion": "4.0.163"
+    "@remotion/bundler": "4.0.164",
+    "@remotion/renderer": "4.0.164",
+    "@remotion/cli": "4.0.164",
+    "remotion": "4.0.164"
   },
   "devDependencies": {
     "@jonny/eslint-config": "3.0.281",
@@ -44,11 +44,11 @@
     "ts-node": "10.9.2",
     "vitest": "0.31.1",
     "zip-lib": "^0.7.2",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.163",
-    "@remotion/bundler": "4.0.163"
+    "@remotion/bundler": "4.0.164",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.164"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.163"
+    "@remotion/bundler": "4.0.164"
   },
   "publishConfig": {
     "access": "public"