@remotion/lambda 4.0.36 → 4.0.38

package/dist/functions/chunk-optimization/plan-frame-ranges.d.ts

@@ -3,5 +3,8 @@ export declare const planFrameRanges: ({ framesPerLambda, frameRange, everyNthFr
     frameRange: [number, number];
     everyNthFrame: number;
 }) => {
-    chunks: [number, number][];
+    chunks: [
+        number,
+        number
+    ][];
 };

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, {
-    type: "render-id-determined";
     renderId: string;
-}, {
     type: "render-id-determined";
+}, {
     renderId: string;
+    type: "render-id-determined";
 }>]>;
 export type StreamingPayloads = z.infer<typeof streamingPayloadSchema>;
 export declare const isStreamingPayload: (str: string) => false | {
-    type: "render-id-determined";
     renderId: string;
+    type: "render-id-determined";
 };
 export declare const sendProgressEvent: (responseStream: ResponseStream, payload: StreamingPayloads) => void;
 export {};

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

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+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 type StreamingPayload = {
+    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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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('');
+    let unprocessedBuffers = [];
+    let missingData = null;
+    const processInput = () => {
+        let separatorIndex = outputBuffer.indexOf(magicSeparator);
+        if (separatorIndex === -1) {
+            return;
+        }
+        separatorIndex += magicSeparator.length;
+        let messageTypeString = '';
+        let lengthString = '';
+        let statusString = '';
+        // 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
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            // 0x3a is the character ":"
+            if (nextDigit === 0x3a) {
+                separatorIndex++;
+                break;
+            }
+            separatorIndex++;
+            messageTypeString += String.fromCharCode(nextDigit);
+        }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            if (nextDigit === 0x3a) {
+                separatorIndex++;
+                break;
+            }
+            separatorIndex++;
+            lengthString += String.fromCharCode(nextDigit);
+        }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            if (nextDigit === 0x3a) {
+                break;
+            }
+            separatorIndex++;
+            statusString += String.fromCharCode(nextDigit);
+        }
+        const length = Number(lengthString);
+        const status = Number(statusString);
+        const dataLength = outputBuffer.length - separatorIndex - 1;
+        if (dataLength < length) {
+            missingData = {
+                dataMissing: length - dataLength,
+            };
+            return;
+        }
+        const data = outputBuffer.subarray(separatorIndex + 1, separatorIndex + 1 + Number(lengthString));
+        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();
+    };
+    return {
+        addData: (data) => {
+            unprocessedBuffers.push(data);
+            const separatorIndex = data.indexOf(magicSeparator);
+            if (separatorIndex === -1) {
+                if (missingData) {
+                    missingData.dataMissing -= data.length;
+                }
+                if (!missingData || missingData.dataMissing > 0) {
+                    return;
+                }
+            }
+            unprocessedBuffers.unshift(outputBuffer);
+            outputBuffer = Buffer.concat(unprocessedBuffers);
+            unprocessedBuffers = [];
+            processInput();
+        },
+    };
+};
+exports.makeStreaming = makeStreaming;
+const makePayloadMessage = ({ message, status, }) => {
+    const body = exports.formatMap[message.type] === 'json'
+        ? Buffer.from(JSON.stringify(message.payload))
+        : message.payload;
+    const concat = Buffer.concat([
+        magicSeparator,
+        Buffer.from((0, exports.messageTypeToMessageId)(message.type).toString()),
+        Buffer.from(':'),
+        Buffer.from(body.length.toString()),
+        Buffer.from(':'),
+        Buffer.from(String(status)),
+        Buffer.from(':'),
+        body,
+    ]);
+    return concat;
+};
+exports.makePayloadMessage = makePayloadMessage;

package/dist/shared/invoke-webhook.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import https from 'https';
 import http from 'node:http';
 import type { EnhancedErrorInfo } from '../functions/helpers/write-lambda-error';

package/dist/shared/is-flaky-error.js

@@ -39,6 +39,9 @@ const isFlakyError = (err) => {
     if (message.includes('RequestTimeout: Your socket connection to the server')) {
         return true;
     }
+    if (message.includes('waiting for the page to render the React component failed')) {
+        return true;
+    }
     return false;
 };
 exports.isFlakyError = isFlakyError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/lambda",
-  "version": "4.0.36",
+  "version": "4.0.38",
   "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/cli": "4.0.36",
-    "@remotion/renderer": "4.0.36",
-    "@remotion/bundler": "4.0.36",
-    "remotion": "4.0.36"
+    "@remotion/cli": "4.0.38",
+    "@remotion/renderer": "4.0.38",
+    "@remotion/bundler": "4.0.38",
+    "remotion": "4.0.38"
   },
   "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.36",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.36"
+    "@remotion/bundler": "4.0.38",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.38"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.36"
+    "@remotion/bundler": "4.0.38"
   },
   "publishConfig": {
     "access": "public"

package/dist/shared/deserialize-input-props.d.ts

@@ -1,8 +0,0 @@
-import type { AwsRegion } from '../client';
-import type { SerializedInputProps } from './constants';
-export declare const deserializeInputProps: ({ serialized, region, bucketName, expectedBucketOwner, }: {
-    serialized: SerializedInputProps;
-    region: AwsRegion;
-    bucketName: string;
-    expectedBucketOwner: string;
-}) => Promise<Record<string, unknown>>;

package/dist/shared/deserialize-input-props.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deserializeInputProps = void 0;
-const io_1 = require("../functions/helpers/io");
-const constants_1 = require("./constants");
-const stream_to_string_1 = require("./stream-to-string");
-const deserializeInputProps = async ({ serialized, region, bucketName, expectedBucketOwner, }) => {
-    if (serialized.type === 'payload') {
-        return JSON.parse(serialized.payload);
-    }
-    try {
-        const response = await (0, io_1.lambdaReadFile)({
-            bucketName,
-            expectedBucketOwner,
-            key: (0, constants_1.inputPropsKey)(serialized.hash),
-            region,
-        });
-        const body = await (0, stream_to_string_1.streamToString)(response);
-        const payload = JSON.parse(body);
-        return payload;
-    }
-    catch (err) {
-        throw new Error(`Failed to parse input props that were serialized: ${err.stack}`);
-    }
-};
-exports.deserializeInputProps = deserializeInputProps;

package/dist/shared/serialize-input-props.d.ts

@@ -1,8 +0,0 @@
-import type { AwsRegion } from '../client';
-import type { SerializedInputProps } from './constants';
-export declare const serializeInputProps: ({ inputProps, region, type, userSpecifiedBucketName, }: {
-    inputProps: Record<string, unknown>;
-    region: AwsRegion;
-    type: 'still' | 'video-or-audio';
-    userSpecifiedBucketName: string | null;
-}) => Promise<SerializedInputProps>;

package/dist/shared/serialize-input-props.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeInputProps = void 0;
-const get_or_create_bucket_1 = require("../api/get-or-create-bucket");
-const io_1 = require("../functions/helpers/io");
-const constants_1 = require("./constants");
-const random_hash_1 = require("./random-hash");
-const serializeInputProps = async ({ inputProps = {}, region, type, userSpecifiedBucketName, }) => {
-    try {
-        const payload = JSON.stringify(inputProps);
-        const hash = (0, random_hash_1.randomHash)();
-        const MAX_INLINE_PAYLOAD_SIZE = type === 'still' ? 5000000 : 200000;
-        if (payload.length > MAX_INLINE_PAYLOAD_SIZE) {
-            console.warn(`Warning: inputProps are over ${Math.round(MAX_INLINE_PAYLOAD_SIZE / 1000)}KB (${Math.ceil(payload.length / 1024)}KB) in size. Uploading them to S3 to circumvent AWS Lambda payload size.`);
-            const bucketName = userSpecifiedBucketName !== null && userSpecifiedBucketName !== void 0 ? userSpecifiedBucketName : (await (0, get_or_create_bucket_1.getOrCreateBucket)({
-                region,
-            })).bucketName;
-            await (0, io_1.lambdaWriteFile)({
-                body: payload,
-                bucketName,
-                region,
-                customCredentials: null,
-                downloadBehavior: null,
-                expectedBucketOwner: null,
-                key: (0, constants_1.inputPropsKey)(hash),
-                privacy: 'public',
-            });
-            return {
-                type: 'bucket-url',
-                hash,
-            };
-        }
-        return {
-            type: 'payload',
-            payload,
-        };
-    }
-    catch (err) {
-        throw new Error('Error serializing inputProps. Check it has no circular references or reduce the size if the object is big.');
-    }
-};
-exports.serializeInputProps = serializeInputProps;