@remotion/lambda 4.0.163 → 4.0.165

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

@@ -4,114 +4,31 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeChunksAndFinishRender = void 0;
-const renderer_1 = require("@remotion/renderer");
 const fs_1 = __importDefault(require("fs"));
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const cleanup_serialized_input_props_1 = require("../../shared/cleanup-serialized-input-props");
-const constants_1 = require("../../shared/constants");
-const truthy_1 = require("../../shared/truthy");
 const concat_videos_1 = require("./concat-videos");
 const create_post_render_data_1 = require("./create-post-render-data");
-const delete_chunks_1 = require("./delete-chunks");
 const get_current_region_1 = require("./get-current-region");
-const get_encoding_progress_step_size_1 = require("./get-encoding-progress-step-size");
-const get_files_to_delete_1 = require("./get-files-to-delete");
 const get_output_url_from_metadata_1 = require("./get-output-url-from-metadata");
 const inspect_errors_1 = require("./inspect-errors");
 const io_1 = require("./io");
-const render_has_audio_video_1 = require("./render-has-audio-video");
 const timer_1 = require("./timer");
-const write_lambda_error_1 = require("./write-lambda-error");
-const write_post_render_data_1 = require("./write-post-render-data");
 const mergeChunksAndFinishRender = async (options) => {
-    let lastProgressUploaded = Date.now();
     const onProgress = (framesEncoded) => {
-        const deltaSinceLastProgressUploaded = Date.now() - lastProgressUploaded;
-        if (deltaSinceLastProgressUploaded < 1500 &&
-            framesEncoded !== options.numberOfFrames) {
-            return;
-        }
-        lastProgressUploaded = Date.now();
-        (0, io_1.lambdaWriteFile)({
-            bucketName: options.bucketName,
-            key: (0, constants_1.encodingProgressKey)(options.renderId),
-            body: String(Math.round(framesEncoded / (0, get_encoding_progress_step_size_1.getEncodingProgressStepSize)(options.numberOfFrames))),
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            privacy: 'private',
-            expectedBucketOwner: options.expectedBucketOwner,
-            downloadBehavior: null,
-            customCredentials: null,
-        }).catch((err) => {
-            (0, write_lambda_error_1.writeLambdaError)({
-                bucketName: options.bucketName,
-                errorInfo: {
-                    chunk: null,
-                    frame: null,
-                    isFatal: false,
-                    name: err.name,
-                    message: err.message,
-                    stack: `Could not upload stitching progress ${err.stack}`,
-                    tmpDir: null,
-                    type: 'stitcher',
-                    attempt: 1,
-                    totalAttempts: 1,
-                    willRetry: false,
-                },
-                renderId: options.renderId,
-                expectedBucketOwner: options.expectedBucketOwner,
-            });
-        });
+        options.overallProgress.setCombinedFrames(framesEncoded);
     };
-    const onErrors = (errors) => {
-        renderer_1.RenderInternals.Log.error({ indent: false, logLevel: options.logLevel }, 'Found Errors', errors);
-        const firstError = errors[0];
-        if (firstError.chunk !== null) {
-            throw new Error(`Stopping Lambda function because error occurred while rendering chunk ${firstError.chunk}:\n${errors[0].stack
-                .split('\n')
-                .map((s) => `   ${s}`)
-                .join('\n')}`);
-        }
-        throw new Error(`Stopping Lambda function because error occurred: ${errors[0].stack}`);
-    };
-    const outdir = (0, node_path_1.join)(renderer_1.RenderInternals.tmpDir(constants_1.CONCAT_FOLDER_TOKEN), 'bucket');
-    if ((0, node_fs_1.existsSync)(outdir)) {
-        (0, node_fs_1.rmSync)(outdir, {
-            recursive: true,
-        });
-    }
-    (0, node_fs_1.mkdirSync)(outdir);
-    const { hasAudio, hasVideo } = (0, render_has_audio_video_1.lambdaRenderHasAudioVideo)(options.renderMetadata);
-    const chunkMultiplier = [hasAudio, hasVideo].filter(truthy_1.truthy).length;
-    const expectedFiles = chunkMultiplier * options.chunkCount;
-    const files = await (0, concat_videos_1.getAllFilesS3)({
-        bucket: options.bucketName,
-        expectedFiles,
-        outdir,
-        renderId: options.renderId,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        expectedBucketOwner: options.expectedBucketOwner,
-        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');
     }
-    const { outfile, cleanupChunksProm } = await (0, concat_videos_1.concatVideosS3)({
+    const { outfile, cleanupChunksProm } = await (0, concat_videos_1.concatVideos)({
         onProgress,
         numberOfFrames: options.numberOfFrames,
         codec: options.codec,
         fps: options.fps,
         numberOfGifLoops: options.numberOfGifLoops,
-        files,
-        outdir,
+        files: options.files,
+        outdir: options.outdir,
         audioCodec: options.audioCodec,
         audioBitrate: options.audioBitrate,
         logLevel: options.logLevel,
@@ -122,8 +39,9 @@ const mergeChunksAndFinishRender = async (options) => {
         muted: options.renderMetadata.muted,
     });
     const encodingStop = Date.now();
-    const outputSize = fs_1.default.statSync(outfile);
-    const writeToS3 = (0, timer_1.timer)(`Writing to S3 (${outputSize.size} bytes)`, options.logLevel);
+    options.overallProgress.setTimeToCombine(encodingStop - encodingStart);
+    const outputSize = fs_1.default.statSync(outfile).size;
+    const writeToS3 = (0, timer_1.timer)(`Writing to S3 (${outputSize} bytes)`, options.logLevel);
     await (0, io_1.lambdaWriteFile)({
         bucketName: options.renderBucketName,
         key: options.key,
@@ -135,44 +53,9 @@ const mergeChunksAndFinishRender = async (options) => {
         customCredentials: options.customCredentials,
     });
     writeToS3.end();
-    const contents = await (0, io_1.lambdaLs)({
-        bucketName: options.bucketName,
-        prefix: (0, constants_1.rendersPrefix)(options.renderId),
-        expectedBucketOwner: options.expectedBucketOwner,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+    const errorExplanations = (0, inspect_errors_1.inspectErrors)({
+        errors: options.overallProgress.get().errors,
     });
-    const finalEncodingProgressProm = (0, io_1.lambdaWriteFile)({
-        bucketName: options.bucketName,
-        key: (0, constants_1.encodingProgressKey)(options.renderId),
-        body: String(Math.ceil(options.numberOfFrames /
-            (0, get_encoding_progress_step_size_1.getEncodingProgressStepSize)(options.numberOfFrames))),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        privacy: 'private',
-        expectedBucketOwner: options.expectedBucketOwner,
-        downloadBehavior: null,
-        customCredentials: null,
-    });
-    const errorExplanationsProm = (0, inspect_errors_1.inspectErrors)({
-        contents,
-        renderId: options.renderId,
-        bucket: options.bucketName,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        expectedBucketOwner: options.expectedBucketOwner,
-    });
-    const jobs = (0, get_files_to_delete_1.getFilesToDelete)({
-        chunkCount: options.chunkCount,
-        renderId: options.renderId,
-        hasAudio,
-        hasVideo,
-    });
-    const deletProm = options.logLevel === 'verbose'
-        ? Promise.resolve(0)
-        : (0, delete_chunks_1.cleanupFiles)({
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            bucket: options.bucketName,
-            contents,
-            jobs,
-        });
     const cleanupSerializedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
         bucketName: options.bucketName,
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
@@ -185,39 +68,23 @@ const mergeChunksAndFinishRender = async (options) => {
     });
     const { url: outputUrl } = (0, get_output_url_from_metadata_1.getOutputUrlFromMetadata)(options.renderMetadata, options.bucketName, options.customCredentials);
     const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
-        expectedBucketOwner: options.expectedBucketOwner,
         region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        renderId: options.renderId,
         memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
         renderMetadata: options.renderMetadata,
-        contents,
-        errorExplanations: await errorExplanationsProm,
-        timeToEncode: encodingStop - encodingStart,
+        errorExplanations,
         timeToDelete: (await Promise.all([
-            deletProm,
             cleanupSerializedInputPropsProm,
             cleanupResolvedInputPropsProm,
-        ])).reduce((a, b) => a + b, 0),
+        ])).reduce((a, b) => Math.max(a, b), 0),
         outputFile: {
-            lastModified: Date.now(),
-            size: outputSize.size,
             url: outputUrl,
         },
+        outputSize,
+        timeToCombine: encodingStop - encodingStart,
+        overallProgress: options.overallProgress.get(),
+        timeToFinish: Date.now() - options.startTime,
     });
-    await finalEncodingProgressProm;
-    await (0, write_post_render_data_1.writePostRenderData)({
-        bucketName: options.bucketName,
-        expectedBucketOwner: options.expectedBucketOwner,
-        postRenderData,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        renderId: options.renderId,
-    });
-    await (0, io_1.lambdaDeleteFile)({
-        bucketName: options.bucketName,
-        key: (0, constants_1.initalizedMetadataKey)(options.renderId),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        customCredentials: null,
-    });
+    options.overallProgress.setPostRenderData(postRenderData);
     await Promise.all([cleanupChunksProm, fs_1.default.promises.rm(outfile)]);
     return postRenderData;
 };

package/dist/functions/helpers/min-max.d.ts

@@ -1,2 +1,2 @@
 export declare const min: (arr: number[]) => number;
-export declare const max: (arr: number[]) => number | null;
+export declare const max: (arr: number[]) => number;

package/dist/functions/helpers/min-max.js

@@ -19,7 +19,7 @@ const min = (arr) => {
 exports.min = min;
 const max = (arr) => {
     if (arr.length === 0) {
-        return null;
+        throw new Error('Array of 0 length');
     }
     let biggest = arr[0];
     for (let i = 0; i < arr.length; i++) {

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

@@ -0,0 +1,49 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { AwsRegion } from '../../client';
+import type { PostRenderData, RenderMetadata } from '../../shared/constants';
+import type { ParsedTiming } from '../../shared/parse-lambda-timings-key';
+import type { ChunkRetry } from './get-retry-stats';
+import type { LambdaErrorInfo } from './write-lambda-error';
+export type OverallRenderProgress = {
+    chunks: number[];
+    framesRendered: number;
+    framesEncoded: number;
+    combinedFrames: number;
+    timeToCombine: number | null;
+    timeToEncode: number | null;
+    timeToRenderFrames: number | null;
+    lambdasInvoked: number;
+    retries: ChunkRetry[];
+    postRenderData: PostRenderData | null;
+    timings: ParsedTiming[];
+    renderMetadata: RenderMetadata | null;
+    errors: LambdaErrorInfo[];
+    timeoutTimestamp: number;
+};
+export type OverallProgressHelper = {
+    upload: () => Promise<void>;
+    setFrames: ({ encoded, rendered, index, }: {
+        rendered: number;
+        encoded: number;
+        index: number;
+    }) => void;
+    setLambdaInvoked: (chunk: number) => void;
+    addChunkCompleted: (chunkIndex: number, start: number, rendered: number) => void;
+    setCombinedFrames: (framesEncoded: number) => void;
+    setTimeToCombine: (timeToCombine: number) => void;
+    addRetry: (retry: ChunkRetry) => void;
+    setPostRenderData: (postRenderData: PostRenderData) => void;
+    setRenderMetadata: (renderMetadata: RenderMetadata) => void;
+    addErrorWithoutUpload: (errorInfo: LambdaErrorInfo) => void;
+    setExpectedChunks: (expectedChunks: number) => void;
+    get: () => OverallRenderProgress;
+};
+export declare const makeInitialOverallRenderProgress: (timeoutTimestamp: number) => OverallRenderProgress;
+export declare const makeOverallRenderProgress: ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, }: {
+    renderId: string;
+    bucketName: string;
+    expectedBucketOwner: string;
+    region: AwsRegion;
+    timeoutTimestamp: number;
+    logLevel: LogLevel;
+}) => OverallProgressHelper;

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOverallRenderProgress = exports.makeInitialOverallRenderProgress = void 0;
+const renderer_1 = require("@remotion/renderer");
+const constants_1 = require("../../shared/constants");
+const io_1 = require("./io");
+const makeInitialOverallRenderProgress = (timeoutTimestamp) => {
+    return {
+        chunks: [],
+        framesRendered: 0,
+        framesEncoded: 0,
+        combinedFrames: 0,
+        timeToCombine: null,
+        timeToEncode: null,
+        lambdasInvoked: 0,
+        retries: [],
+        postRenderData: null,
+        timings: [],
+        renderMetadata: null,
+        errors: [],
+        timeToRenderFrames: null,
+        timeoutTimestamp,
+    };
+};
+exports.makeInitialOverallRenderProgress = makeInitialOverallRenderProgress;
+const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, }) => {
+    let framesRendered = [];
+    let framesEncoded = [];
+    let lambdasInvoked = [];
+    const renderProgress = (0, exports.makeInitialOverallRenderProgress)(timeoutTimestamp);
+    let currentUploadPromise = null;
+    const getCurrentProgress = () => renderProgress;
+    let latestUploadRequest = 0;
+    const getLatestRequestId = () => latestUploadRequest;
+    let encodeStartTime = null;
+    let renderFramesStartTime = null;
+    const upload = async () => {
+        const uploadRequestId = ++latestUploadRequest;
+        if (currentUploadPromise) {
+            await currentUploadPromise;
+        }
+        const toWrite = JSON.stringify(getCurrentProgress());
+        // Deduplicate two fast incoming requests
+        await new Promise((resolve) => {
+            setImmediate(() => resolve());
+        });
+        // If request has been replaced by a new one
+        if (getLatestRequestId() !== uploadRequestId) {
+            return;
+        }
+        const start = Date.now();
+        currentUploadPromise = (0, io_1.lambdaWriteFile)({
+            body: toWrite,
+            bucketName,
+            customCredentials: null,
+            downloadBehavior: null,
+            expectedBucketOwner,
+            key: (0, constants_1.overallProgressKey)(renderId),
+            privacy: 'private',
+            region,
+        })
+            .then(() => {
+            // By default, upload is way too fast (~20 requests per second)
+            // Space out the requests a bit
+            return new Promise((resolve) => {
+                setTimeout(resolve, 500 - (Date.now() - start));
+            });
+        })
+            .catch((err) => {
+            // If an error occurs in uploading the state that contains the errors,
+            // that is unfortunate. We just log it.
+            renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, 'Error uploading progress', err);
+        });
+        await currentUploadPromise;
+        currentUploadPromise = null;
+    };
+    return {
+        upload,
+        setFrames: ({ encoded, rendered, index, }) => {
+            if (framesRendered.length === 0) {
+                throw new Error('Expected chunks to be set before frames are set');
+            }
+            if (framesEncoded.length === 0) {
+                throw new Error('Expected chunks to be set before frames are set');
+            }
+            framesRendered[index] = rendered;
+            framesEncoded[index] = encoded;
+            const totalFramesEncoded = framesEncoded.reduce((a, b) => a + b, 0);
+            const totalFramesRendered = framesRendered.reduce((a, b) => a + b, 0);
+            if (renderProgress.framesEncoded === 0 && totalFramesEncoded > 0) {
+                encodeStartTime = Date.now();
+            }
+            if (renderProgress.framesRendered === 0 && totalFramesRendered > 0) {
+                renderFramesStartTime = Date.now();
+            }
+            if (renderProgress.timeToRenderFrames === null) {
+                const frameCount = renderProgress.renderMetadata &&
+                    renderProgress.renderMetadata.type === 'video'
+                    ? renderer_1.RenderInternals.getFramesToRender(renderProgress.renderMetadata.frameRange, renderProgress.renderMetadata.everyNthFrame).length
+                    : null;
+                if (frameCount === totalFramesRendered) {
+                    const timeToRenderFrames = Date.now() - (renderFramesStartTime !== null && renderFramesStartTime !== void 0 ? renderFramesStartTime : Date.now());
+                    renderProgress.timeToRenderFrames = timeToRenderFrames;
+                }
+            }
+            renderProgress.framesRendered = totalFramesRendered;
+            renderProgress.framesEncoded = totalFramesEncoded;
+            upload();
+        },
+        addChunkCompleted: (chunkIndex, start, rendered) => {
+            var _a;
+            renderProgress.chunks.push(chunkIndex);
+            if (renderProgress.chunks.length ===
+                ((_a = renderProgress.renderMetadata) === null || _a === void 0 ? void 0 : _a.totalChunks)) {
+                const timeToEncode = Date.now() - (encodeStartTime !== null && encodeStartTime !== void 0 ? encodeStartTime : Date.now());
+                renderProgress.timeToEncode = timeToEncode;
+            }
+            renderProgress.timings.push({
+                chunk: chunkIndex,
+                start,
+                rendered,
+            });
+            upload();
+        },
+        setCombinedFrames: (frames) => {
+            renderProgress.combinedFrames = frames;
+            upload();
+        },
+        setTimeToCombine: (timeToCombine) => {
+            renderProgress.timeToCombine = timeToCombine;
+            upload();
+        },
+        setLambdaInvoked(chunk) {
+            if (lambdasInvoked.length === 0) {
+                throw new Error('Expected chunks to be set before lambdas are set');
+            }
+            lambdasInvoked[chunk] = true;
+            renderProgress.lambdasInvoked = lambdasInvoked.reduce((a, b) => a + Number(b), 0);
+            upload();
+        },
+        setPostRenderData(postRenderData) {
+            renderProgress.postRenderData = postRenderData;
+            upload();
+        },
+        setRenderMetadata: (renderMetadata) => {
+            renderProgress.renderMetadata = renderMetadata;
+            upload();
+        },
+        addErrorWithoutUpload: (errorInfo) => {
+            renderProgress.errors.push(errorInfo);
+        },
+        setExpectedChunks: (expectedChunks) => {
+            framesRendered = new Array(expectedChunks).fill(0);
+            framesEncoded = new Array(expectedChunks).fill(0);
+            lambdasInvoked = new Array(expectedChunks).fill(false);
+        },
+        addRetry(retry) {
+            renderProgress.retries.push(retry);
+            upload();
+        },
+        get: () => renderProgress,
+    };
+};
+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,127 @@
+"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 === 'lambda-invoked') {
+                overallProgress.setLambdaInvoked(payload.chunk);
+                return;
+            }
+            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, `chunk:${String(payload.chunk).padStart(8, '0')}: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, `chunk:${String(payload.chunk).padStart(8, '0')}:audio`);
+                (0, fs_1.writeFileSync)(filename, message.payload);
+                files.push(filename);
+                return;
+            }
+            if (message.type === 'chunk-complete') {
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Rendered chunk ${payload.chunk}`);
+                overallProgress.addChunkCompleted(payload.chunk, message.payload.start, message.payload.rendered);
+                return;
+            }
+            if (message.type === 'error-occurred') {
+                overallProgress.addErrorWithoutUpload(message.payload.errorInfo);
+                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,
+                });
+                return;
+            }
+            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;
+        }
+        overallProgress.addRetry({
+            attempt: payload.attempt + 1,
+            time: Date.now(),
+            chunk: payload.chunk,
+        });
+        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/streamify-response.d.ts

@@ -11,7 +11,4 @@ export declare class ResponseStream extends Stream.Writable {
     setContentType(contentType: string): void;
     setIsBase64Encoded(isBase64Encoded: boolean): void;
 }
-export declare const HANDLER_STREAMING: unique symbol;
-export declare const STREAM_RESPONSE = "response";
-export declare function isInAWS(handler: Function): boolean;
 export declare function streamifyResponse(handler: Function): Function;

package/dist/functions/helpers/streamify-response.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamifyResponse = exports.isInAWS = exports.STREAM_RESPONSE = exports.HANDLER_STREAMING = exports.ResponseStream = void 0;
+exports.streamifyResponse = exports.ResponseStream = void 0;
 const stream_1 = require("stream");
 class ResponseStream extends stream_1.Stream.Writable {
     constructor() {
@@ -29,16 +29,6 @@ function patchArgs(argList) {
     }
     return argList[1];
 }
-exports.HANDLER_STREAMING = Symbol.for('aws.lambda.runtime.handler.streaming');
-exports.STREAM_RESPONSE = 'response';
-function isInAWS(handler) {
-    return (
-    // @ts-expect-error
-    handler[exports.HANDLER_STREAMING] !== undefined &&
-        // @ts-expect-error
-        handler[exports.HANDLER_STREAMING] === exports.STREAM_RESPONSE);
-}
-exports.isInAWS = isInAWS;
 function streamifyResponse(handler) {
     // Check if we are inside Lambda
     if (process.env.AWS_LAMBDA_FUNCTION_VERSION &&
@@ -56,9 +46,7 @@ function streamifyResponse(handler) {
                 EventStream: [
                     {
                         PayloadChunk: {
-                            Payload: responseStream._isBase64Encoded
-                                ? responseStream.getBufferedData()
-                                : responseStream.getBufferedData(),
+                            Payload: responseStream.getBufferedData(),
                         },
                         InvokeComplete: true,
                     },

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/helpers/write-lambda-error.d.ts

@@ -17,12 +17,9 @@ export type LambdaErrorInfo = {
 };
 export declare const getTmpDirStateIfENoSp: (err: string) => LambdaErrorInfo['tmpDir'];
 export type EnhancedErrorInfo = LambdaErrorInfo & {
+    /**
+     * @deprecated Will always be an empty string.
+     */
     s3Location: string;
     explanation: string | null;
 };
-export declare const writeLambdaError: ({ bucketName, renderId, errorInfo, expectedBucketOwner, }: {
-    bucketName: string;
-    renderId: string;
-    expectedBucketOwner: string;
-    errorInfo: LambdaErrorInfo;
-}) => Promise<void>;