@remotion/lambda 4.0.164 → 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/streaming.d.ts

@@ -1,4 +1,5 @@
 /// <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";
@@ -7,6 +8,7 @@ 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";
@@ -29,6 +31,9 @@ declare const messageTypes: {
     readonly '7': {
         readonly type: "chunk-complete";
     };
+    readonly '8': {
+        readonly type: "lambda-invoked";
+    };
 };
 export type MessageTypeId = keyof typeof messageTypes;
 type MessageType = (typeof messageTypes)[MessageTypeId]['type'];
@@ -52,6 +57,7 @@ export type StreamingPayload = {
     payload: {
         error: string;
         shouldRetry: boolean;
+        errorInfo: LambdaErrorInfo;
     };
 } | {
     type: typeof renderIdDetermined;
@@ -63,10 +69,17 @@ export type StreamingPayload = {
     payload: RenderStillLambdaResponsePayload;
 } | {
     type: typeof chunkComplete;
-    payload: {};
+    payload: {
+        start: number;
+        rendered: number;
+    };
+} | {
+    type: typeof lambdaInvoked;
+    payload: {
+        attempt: number;
+    };
 };
 export declare const messageTypeIdToMessageType: (messageTypeId: MessageTypeId) => MessageType;
-export declare const messageTypeToMessageId: (messageType: MessageType) => MessageTypeId;
 export type StreamingMessage = {
     successType: 'error' | 'success';
     message: StreamingPayload;

package/dist/functions/streaming/streaming.js

@@ -1,7 +1,7 @@
 "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");
+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';
@@ -9,6 +9,7 @@ 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 },
@@ -17,6 +18,7 @@ const messageTypes = {
     '5': { type: audioChunkRendered },
     '6': { type: stillRendered },
     '7': { type: chunkComplete },
+    '8': { type: lambdaInvoked },
 };
 exports.formatMap = {
     [framesRendered]: 'json',
@@ -26,6 +28,7 @@ exports.formatMap = {
     [audioChunkRendered]: 'binary',
     [stillRendered]: 'json',
     [chunkComplete]: 'json',
+    [lambdaInvoked]: 'json',
 };
 const messageTypeIdToMessageType = (messageTypeId) => {
     const types = messageTypes[messageTypeId];
@@ -42,14 +45,13 @@ const messageTypeToMessageId = (messageType) => {
     }
     return id;
 };
-exports.messageTypeToMessageId = messageTypeToMessageId;
 const makeStreamPayload = ({ message }) => {
     const body = exports.formatMap[message.type] === 'json'
-        ? Buffer.from(JSON.stringify(message.payload))
+        ? new TextEncoder().encode(JSON.stringify(message.payload))
         : message.payload;
-    return client_1.BrowserSafeApis.makeStreamPayloadMessage({
+    return pure_1.NoReactAPIs.makeStreamPayloadMessage({
         body,
-        nonce: (0, exports.messageTypeToMessageId)(message.type),
+        nonce: messageTypeToMessageId(message.type),
         status: 0,
     });
 };

package/dist/internals.d.ts

@@ -1,7 +1,7 @@
 export declare const LambdaInternals: {
     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;
@@ -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;

package/dist/shared/aws-clients.js

@@ -10,6 +10,7 @@ const client_sts_1 = require("@aws-sdk/client-sts");
 const credential_providers_1 = require("@aws-sdk/credential-providers");
 const no_react_1 = require("remotion/no-react");
 const check_credentials_1 = require("./check-credentials");
+const constants_1 = require("./constants");
 const is_in_lambda_1 = require("./is-in-lambda");
 const _clients = {};
 const getCredentials = () => {
@@ -141,6 +142,13 @@ const getServiceClient = ({ region, service, customCredentials, }) => {
                 : new Client({
                     region,
                     credentials: getCredentials(),
+                    requestHandler: service === 'lambda'
+                        ? {
+                            httpsAgent: {
+                                maxSockets: constants_1.MAX_FUNCTIONS_PER_RENDER + 50,
+                            },
+                        }
+                        : undefined,
                 });
         if (process.env.REMOTION_DISABLE_AWS_CLIENT_CACHE) {
             return client;

package/dist/shared/call-lambda.d.ts

@@ -1,4 +1,4 @@
-import type { StreamingPayloads } from '../functions/helpers/streaming-payloads';
+import type { OnMessage } from '../functions/streaming/streaming';
 import type { AwsRegion } from '../pricing/aws-regions';
 import type { LambdaPayloads, LambdaRoutines } from './constants';
 import type { LambdaReturnValues } from './return-values';
@@ -7,10 +7,11 @@ type Options<T extends LambdaRoutines> = {
     type: T;
     payload: Omit<LambdaPayloads[T], 'type'>;
     region: AwsRegion;
-    receivedStreamingPayload: (streamPayload: StreamingPayloads) => void;
     timeoutInTest: number;
 };
-export declare const callLambda: <T extends LambdaRoutines>(options: Options<T> & {
+export declare const callLambda: <T extends LambdaRoutines>(options: Options<T>) => Promise<LambdaReturnValues[T]>;
+export declare const callLambdaWithStreaming: <T extends LambdaRoutines>(options: Options<T> & {
+    receivedStreamingPayload: OnMessage;
     retriesRemaining: number;
-}) => Promise<LambdaReturnValues[T]>;
+}) => Promise<void>;
 export {};