@remotion/lambda 4.0.40 → 4.0.42

package/dist/api/render-media-on-lambda.d.ts

@@ -31,7 +31,7 @@ export type RenderMediaOnLambdaInput = {
     frameRange?: FrameRange;
     outName?: OutNameInput;
     timeoutInMilliseconds?: number;
-    chromiumOptions?: ChromiumOptions;
+    chromiumOptions?: Omit<ChromiumOptions, 'enableMultiProcessOnLinux'>;
     scale?: number;
     everyNthFrame?: number;
     numberOfGifLoops?: number | null;

package/dist/cli/log.d.ts

@@ -2,24 +2,24 @@ export declare const Log: {
     verbose: (message?: any, ...optionalParams: any[]) => void;
     verboseAdvanced: (options: {
         indent: boolean;
-        logLevel: "error" | "verbose" | "info" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     } & {
         tag?: string | undefined;
     }, message?: any, ...optionalParams: any[]) => void;
     info: (message?: any, ...optionalParams: any[]) => void;
     infoAdvanced: (options: {
         indent: boolean;
-        logLevel: "error" | "verbose" | "info" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     }, message?: any, ...optionalParams: any[]) => void;
     warn: (message?: any, ...optionalParams: any[]) => void;
     warnAdvanced: (options: {
         indent: boolean;
-        logLevel: "error" | "verbose" | "info" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     }, message?: any, ...optionalParams: any[]) => void;
     error: (message?: any, ...optionalParams: any[]) => void;
     errorAdvanced: (options: {
         indent: boolean;
-        logLevel: "error" | "verbose" | "info" | "warn";
+        logLevel: "verbose" | "info" | "warn" | "error";
     } & {
         tag?: string | undefined;
     }, message?: any, ...optionalParams: any[]) => void;

package/dist/functions/helpers/check-if-render-exists.js

@@ -8,6 +8,7 @@ const checkIfRenderExists = (contents, renderId, bucketName, region) => {
         return (_a = c.Key) === null || _a === void 0 ? void 0 : _a.startsWith((0, constants_1.initalizedMetadataKey)(renderId));
     }));
     if (!initializedExists) {
+        // ! Error message is checked in progress handler and will be retried. Make sure to update
         throw new TypeError(`No render with ID "${renderId}" found in bucket ${bucketName} and region ${region}`);
     }
 };

package/dist/functions/helpers/get-current-region.d.ts

@@ -1 +1 @@
-export declare const getCurrentRegionInFunction: () => "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-north-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "ap-south-1" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ca-central-1" | "sa-east-1" | "eu-south-1" | "af-south-1" | "ap-east-1" | "me-south-1";
+export declare const getCurrentRegionInFunction: () => "eu-central-1" | "eu-west-1" | "eu-west-2" | "eu-west-3" | "eu-south-1" | "eu-north-1" | "us-east-1" | "us-east-2" | "us-west-1" | "us-west-2" | "af-south-1" | "ap-south-1" | "ap-east-1" | "ap-southeast-1" | "ap-southeast-2" | "ap-northeast-1" | "ap-northeast-2" | "ap-northeast-3" | "ca-central-1" | "me-south-1" | "sa-east-1";

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

@@ -88,6 +88,7 @@ const innerHandler = async (params, responseStream, context) => {
         const response = await (0, progress_1.progressHandler)(params, {
             expectedBucketOwner: currentUserId,
             timeoutInMilliseconds,
+            retriesRemaining: 2,
         });
         responseStream.write(JSON.stringify(response), () => {
             responseStream.end();

package/dist/functions/progress.d.ts

@@ -2,6 +2,7 @@ import type { LambdaPayload, RenderProgress } from '../shared/constants';
 type Options = {
     expectedBucketOwner: string;
     timeoutInMilliseconds: number;
+    retriesRemaining: number;
 };
 export declare const progressHandler: (lambdaParams: LambdaPayload, options: Options) => Promise<RenderProgress>;
 export {};

package/dist/functions/progress.js

@@ -5,7 +5,7 @@ const version_1 = require("remotion/version");
 const constants_1 = require("../shared/constants");
 const get_current_region_1 = require("./helpers/get-current-region");
 const get_progress_1 = require("./helpers/get-progress");
-const progressHandler = (lambdaParams, options) => {
+const progressHandler = async (lambdaParams, options) => {
     var _a;
     if (lambdaParams.type !== constants_1.LambdaRoutines.status) {
         throw new TypeError('Expected status type');
@@ -16,14 +16,33 @@ const progressHandler = (lambdaParams, options) => {
         }
         throw new Error(`Version mismatch: When calling getRenderProgress(), you passed ${process.env.AWS_LAMBDA_FUNCTION_NAME} as the function, which has the version ${version_1.VERSION}, but the @remotion/lambda package you used to invoke the function has version ${lambdaParams.version}. Deploy a new function and use it to call getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
     }
-    return (0, get_progress_1.getProgress)({
-        bucketName: lambdaParams.bucketName,
-        renderId: lambdaParams.renderId,
-        expectedBucketOwner: options.expectedBucketOwner,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
-        timeoutInMilliseconds: options.timeoutInMilliseconds,
-        customCredentials: (_a = lambdaParams.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
-    });
+    try {
+        const progress = await (0, get_progress_1.getProgress)({
+            bucketName: lambdaParams.bucketName,
+            renderId: lambdaParams.renderId,
+            expectedBucketOwner: options.expectedBucketOwner,
+            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+            timeoutInMilliseconds: options.timeoutInMilliseconds,
+            customCredentials: (_a = lambdaParams.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
+        });
+        return progress;
+    }
+    catch (err) {
+        if (options.retriesRemaining === 0) {
+            throw err;
+        }
+        if (err.message.includes('No render with ID')) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 1000);
+            });
+            return (0, exports.progressHandler)(lambdaParams, {
+                expectedBucketOwner: options.expectedBucketOwner,
+                timeoutInMilliseconds: options.timeoutInMilliseconds,
+                retriesRemaining: options.retriesRemaining - 1,
+            });
+        }
+        throw err;
+    }
 };
 exports.progressHandler = progressHandler;

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

@@ -1,12 +1,60 @@
 /// <reference types="node" />
-type OnMessage = (type: 'error' | 'success', nonce: string, data: Buffer) => void;
-export declare const makeStreaming: (onMessage: OnMessage) => {
-    addData: (data: Buffer) => void;
+declare const framesRendered: "frames-rendered";
+declare const errorOccurred: "error-occurred";
+declare const renderIdDetermined: "render-id-determined";
+declare const chunkRendered: "chunk-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: "chunk-rendered";
+    };
+};
+type MessageTypeId = keyof typeof messageTypes;
+type MessageType = (typeof messageTypes)[MessageTypeId]['type'];
+export declare const formatMap: {
+    [key in MessageType]: 'json' | 'binary';
 };
-export declare const makePayloadMessage: (nonce: number, data: Buffer, status: 0 | 1) => Buffer;
 export type StreamingPayload = {
-    type: 'frames-rendered';
-    frames: number;
+    type: typeof framesRendered;
+    payload: {
+        frames: number;
+    };
+} | {
+    type: typeof chunkRendered;
+    payload: Buffer;
+} | {
+    type: typeof errorOccurred;
+    payload: {
+        error: string;
+    };
+} | {
+    type: typeof renderIdDetermined;
+    payload: {
+        renderId: string;
+    };
+};
+export declare const messageTypeIdToMessage: (messageTypeId: MessageTypeId) => MessageType;
+export declare const messageTypeToMessageId: (messageType: MessageType) => MessageTypeId;
+export type OnMessage = (options: {
+    successType: 'error' | 'success';
+    message: StreamingPayload;
+}) => void;
+export declare const makeStreaming: (options: {
+    onMessage: OnMessage;
+}) => {
+    addData: (data: Buffer) => void;
 };
+export declare const makePayloadMessage: ({ message, status, }: {
+    message: StreamingPayload;
+    status: 0 | 1;
+}) => Buffer;
 export type OnStream = (payload: StreamingPayload) => void;
 export {};

package/dist/functions/streaming/streaming.js

@@ -1,21 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makePayloadMessage = exports.makeStreaming = void 0;
-const makeStreaming = (onMessage) => {
+exports.makePayloadMessage = exports.makeStreaming = exports.messageTypeToMessageId = exports.messageTypeIdToMessage = exports.formatMap = void 0;
+const framesRendered = 'frames-rendered';
+const errorOccurred = 'error-occurred';
+const renderIdDetermined = 'render-id-determined';
+const chunkRendered = 'chunk-rendered';
+const messageTypes = {
+    '1': { type: framesRendered },
+    '2': { type: errorOccurred },
+    '3': { type: renderIdDetermined },
+    '4': { type: chunkRendered },
+};
+exports.formatMap = {
+    [framesRendered]: 'json',
+    [errorOccurred]: 'json',
+    [renderIdDetermined]: 'json',
+    [chunkRendered]: 'binary',
+};
+const messageTypeIdToMessage = (messageTypeId) => {
+    const types = messageTypes[messageTypeId];
+    if (!types) {
+        throw new Error(`Unknown message type id ${messageTypeId}`);
+    }
+    return types.type;
+};
+exports.messageTypeIdToMessage = messageTypeIdToMessage;
+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 magicSeparator = Buffer.from('remotion_buffer:');
+const makeStreaming = (options) => {
     let outputBuffer = Buffer.from('');
-    const separator = Buffer.from('remotion_buffer:');
     let unprocessedBuffers = [];
     let missingData = null;
     const processInput = () => {
-        let separatorIndex = outputBuffer.indexOf(separator);
+        let separatorIndex = outputBuffer.indexOf(magicSeparator);
         if (separatorIndex === -1) {
             return;
         }
-        separatorIndex += separator.length;
-        let nonceString = '';
+        separatorIndex += magicSeparator.length;
+        let messageTypeString = '';
         let lengthString = '';
         let statusString = '';
-        // Each message from Rust is prefixed with `remotion_buffer;{[nonce]}:{[length]}`
+        // Each message has the structure with `remotion_buffer:{[message_type_id]}:{[length]}`
         // Let's read the buffer to extract the nonce, and if the full length is available,
         // we'll extract the data and pass it to the callback.
         // eslint-disable-next-line no-constant-condition
@@ -27,7 +59,7 @@ const makeStreaming = (onMessage) => {
                 break;
             }
             separatorIndex++;
-            nonceString += String.fromCharCode(nextDigit);
+            messageTypeString += String.fromCharCode(nextDigit);
         }
         // eslint-disable-next-line no-constant-condition
         while (true) {
@@ -58,7 +90,17 @@ const makeStreaming = (onMessage) => {
             return;
         }
         const data = outputBuffer.subarray(separatorIndex + 1, separatorIndex + 1 + Number(lengthString));
-        onMessage(status === 1 ? 'error' : 'success', nonceString, data);
+        const messageType = (0, exports.messageTypeIdToMessage)(messageTypeString);
+        const payload = {
+            type: messageType,
+            payload: exports.formatMap[messageType] === 'json'
+                ? JSON.parse(data.toString('utf-8'))
+                : data,
+        };
+        options.onMessage({
+            successType: status === 1 ? 'error' : 'success',
+            message: payload,
+        });
         missingData = null;
         outputBuffer = outputBuffer.subarray(separatorIndex + Number(lengthString) + 1);
         processInput();
@@ -66,7 +108,7 @@ const makeStreaming = (onMessage) => {
     return {
         addData: (data) => {
             unprocessedBuffers.push(data);
-            const separatorIndex = data.indexOf(separator);
+            const separatorIndex = data.indexOf(magicSeparator);
             if (separatorIndex === -1) {
                 if (missingData) {
                     missingData.dataMissing -= data.length;
@@ -78,22 +120,24 @@ const makeStreaming = (onMessage) => {
             unprocessedBuffers.unshift(outputBuffer);
             outputBuffer = Buffer.concat(unprocessedBuffers);
             unprocessedBuffers = [];
-            console.log('the unprocessed input is now', new TextDecoder('utf-8').decode(outputBuffer));
             processInput();
         },
     };
 };
 exports.makeStreaming = makeStreaming;
-const makePayloadMessage = (nonce, data, status) => {
+const makePayloadMessage = ({ message, status, }) => {
+    const body = exports.formatMap[message.type] === 'json'
+        ? Buffer.from(JSON.stringify(message.payload))
+        : message.payload;
     const concat = Buffer.concat([
-        Buffer.from('remotion_buffer:'),
-        Buffer.from(nonce.toString()),
+        magicSeparator,
+        Buffer.from((0, exports.messageTypeToMessageId)(message.type).toString()),
         Buffer.from(':'),
-        Buffer.from(data.length.toString()),
+        Buffer.from(body.length.toString()),
         Buffer.from(':'),
         Buffer.from(String(status)),
         Buffer.from(':'),
-        data,
+        body,
     ]);
     return concat;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/lambda",
-  "version": "4.0.40",
+  "version": "4.0.42",
   "description": "Distributed renderer for Remotion based on AWS Lambda",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -26,10 +26,10 @@
     "aws-policies": "^1.0.1",
     "mime-types": "2.1.34",
     "zod": "3.21.4",
-    "@remotion/bundler": "4.0.40",
-    "@remotion/renderer": "4.0.40",
-    "remotion": "4.0.40",
-    "@remotion/cli": "4.0.40"
+    "@remotion/renderer": "4.0.42",
+    "@remotion/bundler": "4.0.42",
+    "remotion": "4.0.42",
+    "@remotion/cli": "4.0.42"
   },
   "devDependencies": {
     "@jonny/eslint-config": "3.0.266",
@@ -43,11 +43,11 @@
     "ts-node": "^10.8.0",
     "vitest": "0.31.1",
     "zip-lib": "^0.7.2",
-    "@remotion/bundler": "4.0.40",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.40"
+    "@remotion/bundler": "4.0.42",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.42"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.40"
+    "@remotion/bundler": "4.0.42"
   },
   "publishConfig": {
     "access": "public"

package/dist/cli/helpers/validate.d.ts

@@ -1,4 +0,0 @@
-import { Internals } from 'remotion';
-export declare const validateFps: typeof Internals.validateFps;
-export declare const validateDimension: typeof Internals.validateDimension;
-export declare const validateDurationInFrames: typeof Internals.validateDurationInFrames;

package/dist/cli/helpers/validate.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDurationInFrames = exports.validateDimension = exports.validateFps = void 0;
-/* eslint-disable prefer-destructuring */
-const remotion_1 = require("remotion");
-exports.validateFps = remotion_1.Internals.validateFps;
-exports.validateDimension = remotion_1.Internals.validateDimension;
-exports.validateDurationInFrames = remotion_1.Internals.validateDurationInFrames;