@remotion/lambda 4.0.163 → 4.0.165

package/dist/functions/renderer.js

@@ -3,13 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rendererHandler = exports.ENABLE_SLOW_LEAK_DETECTION = void 0;
+exports.rendererHandler = void 0;
 const renderer_1 = require("@remotion/renderer");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const version_1 = require("remotion/version");
-const call_lambda_1 = require("../shared/call-lambda");
-const chunk_progress_1 = require("../shared/chunk-progress");
 const compress_props_1 = require("../shared/compress-props");
 const constants_1 = require("../shared/constants");
 const is_flaky_error_1 = require("../shared/is-flaky-error");
@@ -19,11 +17,10 @@ const can_concat_seamlessly_1 = require("./helpers/can-concat-seamlessly");
 const get_browser_instance_1 = require("./helpers/get-browser-instance");
 const get_chromium_executable_path_1 = require("./helpers/get-chromium-executable-path");
 const get_current_region_1 = require("./helpers/get-current-region");
-const io_1 = require("./helpers/io");
 const leak_detection_1 = require("./helpers/leak-detection");
 const on_downloads_logger_1 = require("./helpers/on-downloads-logger");
 const write_lambda_error_1 = require("./helpers/write-lambda-error");
-const renderHandler = async (params, options, logs) => {
+const renderHandler = async ({ params, options, logs, onStream, }) => {
     if (params.type !== constants_1.LambdaRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -98,6 +95,7 @@ const renderHandler = async (params, options, logs) => {
                 : null;
     const resolvedProps = await resolvedPropsPromise;
     const serializedInputPropsWithCustomSchema = await inputPropsPromise;
+    const allFrames = renderer_1.RenderInternals.getFramesToRender(params.frameRange, params.everyNthFrame);
     await new Promise((resolve, reject) => {
         var _a, _b, _c, _d;
         renderer_1.RenderInternals.internalRenderMedia({
@@ -114,24 +112,21 @@ const renderHandler = async (params, options, logs) => {
             serializedInputPropsWithCustomSchema,
             frameRange: params.frameRange,
             onProgress: ({ renderedFrames, encodedFrames, stitchStage }) => {
-                if (renderedFrames % 5 === 0) {
-                    renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, `Rendered ${renderedFrames} frames, encoded ${encodedFrames} frames, stage = ${stitchStage}`);
-                    (0, chunk_progress_1.writeLambdaInitializedFile)({
-                        attempt: params.attempt,
-                        bucketName: params.bucketName,
-                        chunk: params.chunk,
-                        expectedBucketOwner: options.expectedBucketOwner,
-                        framesRendered: renderedFrames,
-                        renderId: params.renderId,
-                    }).catch((err) => {
-                        console.log('Could not write progress', err);
-                        return reject(err);
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Rendered ${renderedFrames} frames, encoded ${encodedFrames} frames, stage = ${stitchStage}`);
+                const allFramesRendered = allFrames.length === renderedFrames;
+                const allFramesEncoded = allFrames.length === encodedFrames;
+                const frameReportPoint = (renderedFrames % params.progressEveryNthFrame === 0 ||
+                    allFramesRendered) &&
+                    !allFramesEncoded;
+                const encodedFramesReportPoint = (encodedFrames % params.progressEveryNthFrame === 0 ||
+                    allFramesEncoded) &&
+                    allFramesRendered;
+                if (frameReportPoint || encodedFramesReportPoint) {
+                    onStream({
+                        type: 'frames-rendered',
+                        payload: { rendered: renderedFrames, encoded: encodedFrames },
                     });
                 }
-                else {
-                    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Rendered ${renderedFrames} frames, encoded ${encodedFrames} frames, stage = ${stitchStage}`);
-                }
-                const allFrames = renderer_1.RenderInternals.getFramesToRender(params.frameRange, params.everyNthFrame);
                 if (renderedFrames === allFrames.length) {
                     renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Rendered all frames!');
                 }
@@ -139,14 +134,12 @@ const renderHandler = async (params, options, logs) => {
             },
             concurrency: params.concurrencyPerLambda,
             onStart: () => {
-                (0, chunk_progress_1.writeLambdaInitializedFile)({
-                    attempt: params.attempt,
-                    bucketName: params.bucketName,
-                    chunk: params.chunk,
-                    expectedBucketOwner: options.expectedBucketOwner,
-                    framesRendered: 0,
-                    renderId: params.renderId,
-                }).catch((err) => reject(err));
+                onStream({
+                    type: 'lambda-invoked',
+                    payload: {
+                        attempt: params.attempt,
+                    },
+                });
             },
             puppeteerInstance: browserInstance.instance,
             serveUrl: params.serveUrl,
@@ -205,46 +198,31 @@ const renderHandler = async (params, options, logs) => {
         })
             .catch((err) => reject(err));
     });
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Streaming chunks to main function');
+    if (audioOutputLocation) {
+        onStream({
+            type: 'audio-chunk-rendered',
+            payload: node_fs_1.default.readFileSync(audioOutputLocation),
+        });
+    }
+    if (videoOutputLocation) {
+        onStream({
+            type: renderer_1.RenderInternals.isAudioCodec(params.codec)
+                ? 'audio-chunk-rendered'
+                : 'video-chunk-rendered',
+            payload: node_fs_1.default.readFileSync(videoOutputLocation),
+        });
+    }
     const endRendered = Date.now();
-    const condensedTimingData = {
-        ...chunkTimingData,
-        timings: Object.values(chunkTimingData.timings),
-    };
-    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Writing chunk to S3');
+    onStream({
+        type: 'chunk-complete',
+        payload: {
+            rendered: endRendered,
+            start,
+        },
+    });
     const writeStart = Date.now();
-    await Promise.all([
-        (0, io_1.lambdaWriteFile)({
-            bucketName: params.bucketName,
-            key: (0, constants_1.chunkKeyForIndex)({
-                renderId: params.renderId,
-                index: params.chunk,
-                type: renderer_1.RenderInternals.isAudioCodec(params.codec) ? 'audio' : 'video',
-            }),
-            body: node_fs_1.default.createReadStream(videoOutputLocation),
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            privacy: params.privacy,
-            expectedBucketOwner: options.expectedBucketOwner,
-            downloadBehavior: null,
-            customCredentials: null,
-        }),
-        audioOutputLocation
-            ? (0, io_1.lambdaWriteFile)({
-                bucketName: params.bucketName,
-                key: (0, constants_1.chunkKeyForIndex)({
-                    renderId: params.renderId,
-                    index: params.chunk,
-                    type: 'audio',
-                }),
-                body: node_fs_1.default.createReadStream(audioOutputLocation),
-                region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-                privacy: params.privacy,
-                expectedBucketOwner: options.expectedBucketOwner,
-                downloadBehavior: null,
-                customCredentials: null,
-            })
-            : null,
-    ]);
-    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Wrote chunk to S3 (${Date.now() - writeStart}ms)`);
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, `Streamed chunk to main function (${Date.now() - writeStart}ms)`);
     renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Cleaning up and writing timings');
     await Promise.all([
         node_fs_1.default.promises.rm(videoOutputLocation, { recursive: true }),
@@ -252,34 +230,19 @@ const renderHandler = async (params, options, logs) => {
             ? node_fs_1.default.promises.rm(audioOutputLocation, { recursive: true })
             : null,
         node_fs_1.default.promises.rm(outputPath, { recursive: true }),
-        (0, io_1.lambdaWriteFile)({
-            bucketName: params.bucketName,
-            body: JSON.stringify(condensedTimingData, null, 2),
-            key: (0, constants_1.lambdaTimingsKey)({
-                renderId: params.renderId,
-                chunk: params.chunk,
-                rendered: endRendered,
-                start,
-            }),
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            privacy: 'private',
-            expectedBucketOwner: options.expectedBucketOwner,
-            downloadBehavior: null,
-            customCredentials: null,
-        }),
     ].filter(truthy_1.truthy));
     renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Done!');
     return {};
 };
-exports.ENABLE_SLOW_LEAK_DETECTION = false;
-const rendererHandler = async (params, options, requestContext) => {
+const ENABLE_SLOW_LEAK_DETECTION = false;
+const rendererHandler = async (params, options, onStream, requestContext) => {
     if (params.type !== constants_1.LambdaRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
     const logs = [];
-    const leakDetection = (0, why_is_node_running_1.enableNodeIntrospection)(exports.ENABLE_SLOW_LEAK_DETECTION);
+    const leakDetection = (0, why_is_node_running_1.enableNodeIntrospection)(ENABLE_SLOW_LEAK_DETECTION);
     try {
-        await renderHandler(params, options, logs);
+        await renderHandler({ params, options, logs, onStream });
         return {
             type: 'success',
         };
@@ -293,45 +256,29 @@ const rendererHandler = async (params, options, requestContext) => {
         // is a very rare error to occur
         const isRetryableError = (0, is_flaky_error_1.isFlakyError)(err);
         const shouldNotRetry = err.name === 'CancelledError';
-        const willRetry = isRetryableError && params.retriesLeft > 0 && !shouldNotRetry;
-        const isFatal = !willRetry;
-        console.log(`Error occurred (will retry = ${String(willRetry)})`);
-        console.log(err);
-        await (0, write_lambda_error_1.writeLambdaError)({
-            bucketName: params.bucketName,
-            errorInfo: {
-                name: err.name,
-                message: err.message,
-                stack: err.stack,
-                chunk: params.chunk,
-                frame: null,
-                type: 'renderer',
-                isFatal,
-                tmpDir: (0, write_lambda_error_1.getTmpDirStateIfENoSp)(err.stack),
-                attempt: params.attempt,
-                totalAttempts: params.retriesLeft + params.attempt,
-                willRetry,
+        const shouldRetry = isRetryableError && params.retriesLeft > 0 && !shouldNotRetry;
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, `Error occurred (will retry = ${String(shouldRetry)})`);
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, err);
+        onStream({
+            type: 'error-occurred',
+            payload: {
+                error: err.stack,
+                shouldRetry,
+                errorInfo: {
+                    name: err.name,
+                    message: err.message,
+                    stack: err.stack,
+                    chunk: params.chunk,
+                    frame: null,
+                    type: 'renderer',
+                    isFatal: !shouldRetry,
+                    tmpDir: (0, write_lambda_error_1.getTmpDirStateIfENoSp)(err.stack),
+                    attempt: params.attempt,
+                    totalAttempts: params.retriesLeft + params.attempt,
+                    willRetry: shouldRetry,
+                },
             },
-            renderId: params.renderId,
-            expectedBucketOwner: options.expectedBucketOwner,
         });
-        if (willRetry) {
-            const retryPayload = {
-                ...params,
-                retriesLeft: params.retriesLeft - 1,
-                attempt: params.attempt + 1,
-            };
-            const res = await (0, call_lambda_1.callLambda)({
-                functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
-                payload: retryPayload,
-                type: constants_1.LambdaRoutines.renderer,
-                region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-                receivedStreamingPayload: () => undefined,
-                timeoutInTest: 120000,
-                retriesRemaining: 0,
-            });
-            return res;
-        }
         throw err;
     }
     finally {

package/dist/functions/start.d.ts

@@ -1,6 +1,7 @@
 import type { LambdaPayload } from '../shared/constants';
 type Options = {
     expectedBucketOwner: string;
+    timeoutInMilliseconds: number;
 };
 export declare const startHandler: (params: LambdaPayload, options: Options) => Promise<{
     type: "success";

package/dist/functions/start.js

@@ -10,6 +10,7 @@ const convert_to_serve_url_1 = require("../shared/convert-to-serve-url");
 const get_current_region_1 = require("./helpers/get-current-region");
 const io_1 = require("./helpers/io");
 const lifecycle_1 = require("./helpers/lifecycle");
+const overall_render_progress_1 = require("./helpers/overall-render-progress");
 const startHandler = async (params, options) => {
     var _a;
     if (params.type !== constants_1.LambdaRoutines.start) {
@@ -38,9 +39,9 @@ const startHandler = async (params, options) => {
         bucketName,
         downloadBehavior: null,
         region,
-        body: 'Render was initialized',
+        body: JSON.stringify((0, overall_render_progress_1.makeInitialOverallRenderProgress)(options.timeoutInMilliseconds + Date.now())),
         expectedBucketOwner: options.expectedBucketOwner,
-        key: (0, constants_1.initalizedMetadataKey)(renderId),
+        key: (0, constants_1.overallProgressKey)(renderId),
         privacy: 'private',
         customCredentials: null,
     });

package/dist/functions/still.d.ts

@@ -1,10 +1,13 @@
 import type { CostsInfo, LambdaPayload } from '../shared/constants';
+import type { OnStream } from './streaming/streaming';
 type Options = {
     params: LambdaPayload;
     renderId: string;
     expectedBucketOwner: string;
+    onStream: OnStream;
+    timeoutInMilliseconds: number;
 };
-type RenderStillLambdaResponsePayload = {
+export type RenderStillLambdaResponsePayload = {
     type: 'success';
     output: string;
     outKey: string;
@@ -14,5 +17,7 @@ type RenderStillLambdaResponsePayload = {
     estimatedPrice: CostsInfo;
     renderId: string;
 };
-export declare const stillHandler: (options: Options) => Promise<RenderStillLambdaResponsePayload>;
+export declare const stillHandler: (options: Options) => Promise<{
+    type: 'success';
+}>;
 export {};

package/dist/functions/still.js

@@ -28,9 +28,9 @@ const get_current_region_1 = require("./helpers/get-current-region");
 const get_output_url_from_metadata_1 = require("./helpers/get-output-url-from-metadata");
 const io_1 = require("./helpers/io");
 const on_downloads_logger_1 = require("./helpers/on-downloads-logger");
+const overall_render_progress_1 = require("./helpers/overall-render-progress");
 const validate_composition_1 = require("./helpers/validate-composition");
-const write_lambda_error_1 = require("./helpers/write-lambda-error");
-const innerStillHandler = async ({ params: lambdaParams, expectedBucketOwner, renderId, }) => {
+const innerStillHandler = async ({ params: lambdaParams, expectedBucketOwner, renderId, onStream, timeoutInMilliseconds, }) => {
     var _a, _b, _c, _d, _e;
     if (lambdaParams.type !== constants_1.LambdaRoutines.still) {
         throw new TypeError('Expected still type');
@@ -127,10 +127,12 @@ const innerStillHandler = async ({ params: lambdaParams, expectedBucketOwner, re
         downloadBehavior: lambdaParams.downloadBehavior,
         audioBitrate: null,
     };
+    const still = (0, overall_render_progress_1.makeInitialOverallRenderProgress)(timeoutInMilliseconds);
+    still.renderMetadata = renderMetadata;
     await (0, io_1.lambdaWriteFile)({
         bucketName,
-        key: (0, constants_1.renderMetadataKey)(renderId),
-        body: JSON.stringify(renderMetadata),
+        key: (0, constants_1.overallProgressKey)(renderId),
+        body: JSON.stringify(still),
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
         privacy: 'private',
         expectedBucketOwner,
@@ -205,7 +207,7 @@ const innerStillHandler = async ({ params: lambdaParams, expectedBucketOwner, re
         diskSizeInMb: constants_1.MAX_EPHEMERAL_STORAGE_IN_MB,
     });
     const { key: outKey, url } = (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(renderMetadata, bucketName, customCredentials);
-    return {
+    const payload = {
         type: 'success',
         output: url,
         size,
@@ -215,15 +217,19 @@ const innerStillHandler = async ({ params: lambdaParams, expectedBucketOwner, re
         renderId,
         outKey,
     };
+    onStream({
+        type: 'still-rendered',
+        payload,
+    });
 };
 const stillHandler = async (options) => {
-    var _a;
     const { params } = options;
     if (params.type !== constants_1.LambdaRoutines.still) {
         throw new Error('Params must be renderer');
     }
     try {
-        return await innerStillHandler(options);
+        await innerStillHandler(options);
+        return { type: 'success' };
     }
     catch (err) {
         // If this error is encountered, we can just retry as it
@@ -233,6 +239,10 @@ const stillHandler = async (options) => {
         if (!willRetry) {
             throw err;
         }
+        renderer_1.RenderInternals.Log.error({
+            indent: false,
+            logLevel: params.logLevel,
+        }, 'Got error:', err.stack, 'Will retry.');
         const retryPayload = {
             ...params,
             maxRetries: params.maxRetries - 1,
@@ -243,34 +253,7 @@ const stillHandler = async (options) => {
             payload: retryPayload,
             region: (0, get_current_region_1.getCurrentRegionInFunction)(),
             type: constants_1.LambdaRoutines.still,
-            receivedStreamingPayload: () => undefined,
             timeoutInTest: 120000,
-            retriesRemaining: 0,
-        });
-        const bucketName = (_a = params.bucketName) !== null && _a !== void 0 ? _a : (await (0, get_or_create_bucket_1.internalGetOrCreateBucket)({
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            enableFolderExpiry: null,
-            customCredentials: null,
-        })).bucketName;
-        // `await` elided on purpose here; using `void` to mark it as intentional
-        // eslint-disable-next-line no-void
-        void (0, write_lambda_error_1.writeLambdaError)({
-            bucketName,
-            errorInfo: {
-                chunk: null,
-                frame: null,
-                isFatal: false,
-                name: err.name,
-                message: err.message,
-                stack: err.stack,
-                type: 'browser',
-                tmpDir: (0, write_lambda_error_1.getTmpDirStateIfENoSp)(err.stack),
-                attempt: params.attempt,
-                totalAttempts: params.attempt + params.maxRetries,
-                willRetry,
-            },
-            expectedBucketOwner: options.expectedBucketOwner,
-            renderId: options.renderId,
         });
         return res;
     }

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,92 @@
+/// <reference types="node" />
+import type { LambdaErrorInfo } from '../helpers/write-lambda-error';
+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 lambdaInvoked: "lambda-invoked";
+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";
+    };
+    readonly '8': {
+        readonly type: "lambda-invoked";
+    };
+};
+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;
+        errorInfo: LambdaErrorInfo;
+    };
+} | {
+    type: typeof renderIdDetermined;
+    payload: {
+        renderId: string;
+    };
+} | {
+    type: typeof stillRendered;
+    payload: RenderStillLambdaResponsePayload;
+} | {
+    type: typeof chunkComplete;
+    payload: {
+        start: number;
+        rendered: number;
+    };
+} | {
+    type: typeof lambdaInvoked;
+    payload: {
+        attempt: number;
+    };
+};
+export declare const messageTypeIdToMessageType: (messageTypeId: MessageTypeId) => MessageType;
+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,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStreamPayload = exports.messageTypeIdToMessageType = exports.formatMap = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+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 lambdaInvoked = 'lambda-invoked';
+const messageTypes = {
+    '1': { type: framesRendered },
+    '2': { type: errorOccurred },
+    '3': { type: renderIdDetermined },
+    '4': { type: videoChunkRendered },
+    '5': { type: audioChunkRendered },
+    '6': { type: stillRendered },
+    '7': { type: chunkComplete },
+    '8': { type: lambdaInvoked },
+};
+exports.formatMap = {
+    [framesRendered]: 'json',
+    [errorOccurred]: 'json',
+    [renderIdDetermined]: 'json',
+    [videoChunkRendered]: 'binary',
+    [audioChunkRendered]: 'binary',
+    [stillRendered]: 'json',
+    [chunkComplete]: 'json',
+    [lambdaInvoked]: '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;
+};
+const makeStreamPayload = ({ message }) => {
+    const body = exports.formatMap[message.type] === 'json'
+        ? new TextEncoder().encode(JSON.stringify(message.payload))
+        : message.payload;
+    return pure_1.NoReactAPIs.makeStreamPayloadMessage({
+        body,
+        nonce: messageTypeToMessageId(message.type),
+        status: 0,
+    });
+};
+exports.makeStreamPayload = makeStreamPayload;

package/dist/internals.d.ts

@@ -1,7 +1,7 @@
 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;
+    getRenderProgressPayload: ({ bucketName, renderId, s3OutputProvider, logLevel, }: import("./client").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<{
         type: import("./defaults").LambdaRoutines.still;
         serveUrl: string;
@@ -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;
@@ -26,6 +26,7 @@ export declare const LambdaInternals: {
         bucketName: string | null;
         offthreadVideoCacheSizeInBytes: number | null;
         deleteAfter: "1-day" | "3-days" | "7-days" | "30-days" | null;
+        streamed: boolean;
     }>;
     internalDeploySite: (args_0: {
         entryPoint: string;
@@ -56,11 +57,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;