@remotion/lambda 4.0.164 → 4.0.166

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

@@ -4,108 +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,
-    });
     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,
@@ -116,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,
@@ -129,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 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 errorExplanations = (0, inspect_errors_1.inspectErrors)({
+        errors: options.overallProgress.get().errors,
     });
-    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)(),
@@ -179,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

@@ -1,27 +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>;
-    finishUploading: () => void;
     setFrames: ({ encoded, rendered, index, }: {
         rendered: number;
         encoded: number;
         index: number;
     }) => void;
-    addChunkCompleted: (chunkIndex: 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 makeOverallRenderProgress: ({ renderId, bucketName, expectedBucketOwner, region, expectedChunks, }: {
+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;
-    expectedChunks: number;
+    timeoutTimestamp: number;
+    logLevel: LogLevel;
 }) => OverallProgressHelper;

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

@@ -1,41 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeOverallRenderProgress = void 0;
+exports.makeOverallRenderProgress = exports.makeInitialOverallRenderProgress = void 0;
+const renderer_1 = require("@remotion/renderer");
 const constants_1 = require("../../shared/constants");
 const io_1 = require("./io");
-const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, expectedChunks, }) => {
-    const framesRendered = new Array(expectedChunks).fill(0);
-    const framesEncoded = new Array(expectedChunks).fill(0);
-    const renderProgress = {
+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;
-    let lastUpload = null;
-    let stopUploading = false;
-    const finishUploading = () => {
-        stopUploading = true;
-    };
-    // TODO: What if upload fails?
+    const getCurrentProgress = () => renderProgress;
+    let latestUploadRequest = 0;
+    const getLatestRequestId = () => latestUploadRequest;
+    let encodeStartTime = null;
+    let renderFramesStartTime = null;
     const upload = async () => {
-        if (stopUploading) {
-            return;
-        }
-        if (lastUpload === JSON.stringify(renderProgress)) {
-            return;
-        }
+        const uploadRequestId = ++latestUploadRequest;
         if (currentUploadPromise) {
-            currentUploadPromise = currentUploadPromise.then(() => {
-                currentUploadPromise = null;
-                return upload();
-            });
+            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: JSON.stringify(renderProgress),
+            body: toWrite,
             bucketName,
             customCredentials: null,
             downloadBehavior: null,
@@ -43,23 +58,68 @@ const makeOverallRenderProgress = ({ renderId, bucketName, 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;
-        lastUpload = JSON.stringify(renderProgress);
         currentUploadPromise = null;
     };
     return {
         upload,
-        finishUploading,
         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;
-            renderProgress.framesRendered = framesRendered.reduce((a, b) => a + b, 0);
-            renderProgress.framesEncoded = framesEncoded.reduce((a, b) => a + b, 0);
+            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) => {
+        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) => {
@@ -70,6 +130,35 @@ const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner,
             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.js

@@ -13,6 +13,10 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
     }
     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,
@@ -22,28 +26,24 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
                 return;
             }
             if (message.type === 'video-chunk-rendered') {
-                const filename = (0, path_1.join)(outdir, (0, defaults_1.chunkKeyForIndex)({
-                    index: payload.chunk,
-                    type: 'video',
-                }));
+                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, (0, defaults_1.chunkKeyForIndex)({
-                    index: payload.chunk,
-                    type: 'audio',
-                }));
+                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') {
-                overallProgress.addChunkCompleted(payload.chunk);
+                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,
@@ -62,6 +62,7 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
                     error: message.payload.error,
                     shouldRetry: message.payload.shouldRetry,
                 });
+                return;
             }
             throw new Error(`Unknown message type ${message.type}`);
         };
@@ -104,6 +105,11 @@ const streamRendererFunctionWithRetry = async ({ payload, files, functionName, o
         if (!result.shouldRetry) {
             throw result.error;
         }
+        overallProgress.addRetry({
+            attempt: payload.attempt + 1,
+            time: Date.now(),
+            chunk: payload.chunk,
+        });
         return (0, exports.streamRendererFunctionWithRetry)({
             files,
             functionName,

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/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>;

package/dist/functions/helpers/write-lambda-error.js

@@ -1,10 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeLambdaError = exports.getTmpDirStateIfENoSp = void 0;
-const constants_1 = require("../../shared/constants");
-const get_current_region_1 = require("./get-current-region");
+exports.getTmpDirStateIfENoSp = void 0;
 const get_files_in_folder_1 = require("./get-files-in-folder");
-const io_1 = require("./io");
 const is_enosp_err_1 = require("./is-enosp-err");
 const getTmpDirStateIfENoSp = (err) => {
     if (!(0, is_enosp_err_1.errorIsOutOfSpaceError)(err)) {
@@ -21,20 +18,3 @@ const getTmpDirStateIfENoSp = (err) => {
     };
 };
 exports.getTmpDirStateIfENoSp = getTmpDirStateIfENoSp;
-const writeLambdaError = async ({ bucketName, renderId, errorInfo, expectedBucketOwner, }) => {
-    await (0, io_1.lambdaWriteFile)({
-        bucketName,
-        key: `${(0, constants_1.getErrorFileName)({
-            renderId,
-            chunk: errorInfo.chunk,
-            attempt: errorInfo.attempt,
-        })}.txt`,
-        body: JSON.stringify(errorInfo),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        privacy: 'private',
-        expectedBucketOwner,
-        downloadBehavior: null,
-        customCredentials: null,
-    });
-};
-exports.writeLambdaError = writeLambdaError;

package/dist/functions/index.d.ts

@@ -1 +1,6 @@
+export type OrError<T> = T | {
+    type: 'error';
+    message: string;
+    stack: string;
+};
 export declare const handler: Function;