@remotion/lambda 4.0.163 → 4.0.165

package/dist/functions/helpers/get-progress.js

@@ -4,192 +4,116 @@ exports.getProgress = void 0;
 const renderer_1 = require("@remotion/renderer");
 const no_react_1 = require("remotion/no-react");
 const constants_1 = require("../../shared/constants");
-const parse_chunk_key_1 = require("../../shared/parse-chunk-key");
 const truthy_1 = require("../../shared/truthy");
 const calculate_chunk_times_1 = require("./calculate-chunk-times");
 const calculate_price_from_bucket_1 = require("./calculate-price-from-bucket");
-const check_if_render_exists_1 = require("./check-if-render-exists");
 const expected_out_name_1 = require("./expected-out-name");
-const find_output_file_in_bucket_1 = require("./find-output-file-in-bucket");
 const format_costs_info_1 = require("./format-costs-info");
-const get_cleanup_progress_1 = require("./get-cleanup-progress");
-const get_current_region_1 = require("./get-current-region");
-const get_encoding_metadata_1 = require("./get-encoding-metadata");
-const get_encoding_progress_step_size_1 = require("./get-encoding-progress-step-size");
-const get_final_encoding_status_1 = require("./get-final-encoding-status");
-const get_lambdas_invoked_stats_1 = require("./get-lambdas-invoked-stats");
 const get_overall_progress_1 = require("./get-overall-progress");
-const get_post_render_data_1 = require("./get-post-render-data");
-const get_render_metadata_1 = require("./get-render-metadata");
-const get_rendered_frames_progress_1 = require("./get-rendered-frames-progress");
-const get_retry_stats_1 = require("./get-retry-stats");
-const get_time_to_finish_1 = require("./get-time-to-finish");
+const get_overall_progress_s3_1 = require("./get-overall-progress-s3");
 const inspect_errors_1 = require("./inspect-errors");
-const io_1 = require("./io");
 const make_timeout_error_1 = require("./make-timeout-error");
 const render_has_audio_video_1 = require("./render-has-audio-video");
 const getProgress = async ({ bucketName, renderId, expectedBucketOwner, region, memorySizeInMb, timeoutInMilliseconds, customCredentials, }) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    const postRenderData = await (0, get_post_render_data_1.getPostRenderData)({
-        bucketName,
-        region,
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    const overallProgress = await (0, get_overall_progress_s3_1.getOverallProgressS3)({
         renderId,
+        bucketName,
         expectedBucketOwner,
+        region,
     });
-    if (postRenderData) {
-        const outData = (0, expected_out_name_1.getExpectedOutName)(postRenderData.renderMetadata, bucketName, customCredentials);
-        const totalFrameCount = postRenderData.renderMetadata.type === 'still'
+    if (overallProgress.postRenderData) {
+        if (!overallProgress.renderMetadata) {
+            throw new Error('No render metadata found even though render is finished');
+        }
+        const outData = (0, expected_out_name_1.getExpectedOutName)(overallProgress.renderMetadata, bucketName, customCredentials);
+        const totalFrameCount = overallProgress.renderMetadata.type === 'still'
             ? 1
-            : renderer_1.RenderInternals.getFramesToRender(postRenderData.renderMetadata.frameRange, postRenderData.renderMetadata.everyNthFrame).length;
+            : renderer_1.RenderInternals.getFramesToRender(overallProgress.renderMetadata.frameRange, overallProgress.renderMetadata.everyNthFrame).length;
         return {
             framesRendered: totalFrameCount,
             bucket: bucketName,
-            renderSize: postRenderData.renderSize,
-            chunks: postRenderData.renderMetadata.totalChunks,
+            renderSize: overallProgress.postRenderData.renderSize,
+            chunks: overallProgress.renderMetadata.totalChunks,
             cleanup: {
-                doneIn: postRenderData.timeToCleanUp,
-                filesDeleted: postRenderData.filesCleanedUp,
-                minFilesToDelete: postRenderData.filesCleanedUp,
+                doneIn: overallProgress.postRenderData.timeToCleanUp,
+                filesDeleted: overallProgress.postRenderData.filesCleanedUp,
+                minFilesToDelete: overallProgress.postRenderData.filesCleanedUp,
             },
             costs: {
-                accruedSoFar: postRenderData.cost.estimatedCost,
-                displayCost: postRenderData.cost.estimatedDisplayCost,
-                currency: postRenderData.cost.currency,
-                disclaimer: postRenderData.cost.disclaimer,
+                accruedSoFar: overallProgress.postRenderData.cost.estimatedCost,
+                displayCost: overallProgress.postRenderData.cost.estimatedDisplayCost,
+                currency: overallProgress.postRenderData.cost.currency,
+                disclaimer: overallProgress.postRenderData.cost.disclaimer,
             },
             currentTime: Date.now(),
             done: true,
             encodingStatus: {
                 framesEncoded: totalFrameCount,
+                combinedFrames: totalFrameCount,
+                timeToCombine: overallProgress.postRenderData.timeToCombine,
             },
-            errors: postRenderData.errors,
+            errors: overallProgress.postRenderData.errors,
             fatalErrorEncountered: false,
-            lambdasInvoked: postRenderData.renderMetadata.totalChunks,
-            outputFile: postRenderData.outputFile,
+            lambdasInvoked: overallProgress.renderMetadata.totalChunks,
+            outputFile: overallProgress.postRenderData.outputFile,
             renderId,
-            renderMetadata: postRenderData.renderMetadata,
-            timeToFinish: postRenderData.timeToFinish,
-            timeToFinishChunks: postRenderData.timeToRenderChunks,
+            timeToFinish: overallProgress.postRenderData.timeToFinish,
+            timeToFinishChunks: overallProgress.postRenderData.timeToRenderChunks,
+            timeToRenderFrames: overallProgress.postRenderData.timeToRenderFrames,
             overallProgress: 1,
-            retriesInfo: postRenderData.retriesInfo,
+            retriesInfo: overallProgress.postRenderData.retriesInfo,
             outKey: outData.key,
             outBucket: outData.renderBucketName,
-            mostExpensiveFrameRanges: (_a = postRenderData.mostExpensiveFrameRanges) !== null && _a !== void 0 ? _a : null,
-            timeToEncode: postRenderData.timeToEncode,
-            outputSizeInBytes: postRenderData.outputSize,
+            mostExpensiveFrameRanges: (_a = overallProgress.postRenderData.mostExpensiveFrameRanges) !== null && _a !== void 0 ? _a : null,
+            timeToEncode: overallProgress.postRenderData.timeToEncode,
+            outputSizeInBytes: overallProgress.postRenderData.outputSize,
             type: 'success',
-            estimatedBillingDurationInMilliseconds: postRenderData.estimatedBillingDurationInMilliseconds,
+            estimatedBillingDurationInMilliseconds: overallProgress.postRenderData.estimatedBillingDurationInMilliseconds,
+            timeToCombine: overallProgress.postRenderData.timeToCombine,
+            combinedFrames: totalFrameCount,
+            renderMetadata: overallProgress.renderMetadata,
+            timeoutTimestamp: overallProgress.timeoutTimestamp,
         };
     }
-    const contents = await (0, io_1.lambdaLs)({
-        bucketName,
-        prefix: (0, constants_1.rendersPrefix)(renderId),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-        expectedBucketOwner,
+    const { renderMetadata } = overallProgress;
+    const errorExplanations = (0, inspect_errors_1.inspectErrors)({
+        errors: overallProgress.errors,
     });
-    const renderMetadataExists = Boolean(contents.find((c) => c.Key === (0, constants_1.renderMetadataKey)(renderId)));
-    const [renderMetadata, errorExplanations] = await Promise.all([
-        renderMetadataExists
-            ? (0, get_render_metadata_1.getRenderMetadata)({
-                bucketName,
-                renderId,
-                region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-                expectedBucketOwner,
-            })
-            : null,
-        (0, inspect_errors_1.inspectErrors)({
-            contents,
-            renderId,
-            bucket: bucketName,
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
-            expectedBucketOwner,
-        }),
-    ]);
-    if ((renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.type) === 'still') {
+    if (renderMetadata && renderMetadata.type === 'still') {
         throw new Error("You don't need to call getRenderProgress() on a still render. Once you have obtained the `renderId`, the render is already done! 😉");
     }
-    (0, check_if_render_exists_1.checkIfRenderExists)(contents, renderId, bucketName, (0, get_current_region_1.getCurrentRegionInFunction)());
-    const outputFile = renderMetadata
-        ? await (0, find_output_file_in_bucket_1.findOutputFileInBucket)({
-            bucketName,
-            renderMetadata,
-            region,
-            customCredentials,
-        })
-        : null;
     const priceFromBucket = (0, calculate_price_from_bucket_1.estimatePriceFromBucket)({
-        contents,
         renderMetadata,
         memorySizeInMb,
-        outputFileMetadata: outputFile,
         lambdasInvoked: (_b = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.estimatedRenderLambdaInvokations) !== null && _b !== void 0 ? _b : 0,
         // We cannot determine the ephemeral storage size, so we
         // overestimate the price, but will only have a miniscule effect (~0.2%)
         diskSizeInMb: constants_1.MAX_EPHEMERAL_STORAGE_IN_MB,
+        timings: (_c = overallProgress.timings) !== null && _c !== void 0 ? _c : [],
     });
     const { hasAudio, hasVideo } = renderMetadata
         ? (0, render_has_audio_video_1.lambdaRenderHasAudioVideo)(renderMetadata)
         : { hasAudio: false, hasVideo: false };
-    const cleanup = (0, get_cleanup_progress_1.getCleanupProgress)({
-        chunkCount: (_c = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.totalChunks) !== null && _c !== void 0 ? _c : 0,
-        contents,
-        output: (_d = outputFile === null || outputFile === void 0 ? void 0 : outputFile.url) !== null && _d !== void 0 ? _d : null,
-        renderId,
-        hasAudio,
-        hasVideo,
-    });
-    const timeToFinish = (0, get_time_to_finish_1.getTimeToFinish)({
-        lastModified: (_e = outputFile === null || outputFile === void 0 ? void 0 : outputFile.lastModified) !== null && _e !== void 0 ? _e : null,
-        renderMetadata,
-    });
+    const cleanup = {
+        doneIn: null,
+        minFilesToDelete: 0,
+        filesDeleted: 0,
+    };
     const chunkMultiplier = [hasAudio, hasVideo].filter(truthy_1.truthy).length;
-    const chunks = contents.filter((c) => { var _a; return (_a = c.Key) === null || _a === void 0 ? void 0 : _a.startsWith((0, constants_1.chunkKey)(renderId)); });
-    const framesRendered = renderMetadata
-        ? (0, get_rendered_frames_progress_1.getRenderedFramesProgress)({
-            contents,
-            everyNthFrame: renderMetadata.everyNthFrame,
-            frameRange: renderMetadata.frameRange,
-            framesPerLambda: renderMetadata.framesPerLambda,
-            renderId,
-        })
-        : 0;
-    const allChunks = chunks.length / chunkMultiplier ===
-        ((_f = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.totalChunks) !== null && _f !== void 0 ? _f : Infinity);
-    const renderSize = contents
-        .map((c) => { var _a; return (_a = c.Size) !== null && _a !== void 0 ? _a : 0; })
-        .reduce((a, b) => a + b, 0);
-    const lambdasInvokedStats = (0, get_lambdas_invoked_stats_1.getLambdasInvokedStats)({
-        contents,
-        renderId,
-    });
-    const retriesInfo = (0, get_retry_stats_1.getRetryStats)({
-        contents,
-        renderId,
-    });
+    const allChunks = ((_d = overallProgress.chunks) !== null && _d !== void 0 ? _d : []).length / chunkMultiplier ===
+        ((_e = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.totalChunks) !== null && _e !== void 0 ? _e : Infinity);
     const frameCount = renderMetadata
         ? renderer_1.RenderInternals.getFramesToRender(renderMetadata.frameRange, renderMetadata.everyNthFrame).length
         : null;
-    const frameCountOrNull = frameCount === null ? 0 : frameCount;
-    const encodingStatus = (0, get_encoding_metadata_1.getEncodingMetadata)({
-        exists: contents.find((c) => c.Key === (0, constants_1.encodingProgressKey)(renderId)),
-        frameCount: frameCountOrNull,
-        stepSize: (0, get_encoding_progress_step_size_1.getEncodingProgressStepSize)(frameCountOrNull),
-    });
-    const finalEncodingStatus = (0, get_final_encoding_status_1.getFinalEncodingStatus)({
-        encodingProgress: encodingStatus,
-        outputFileExists: Boolean(outputFile),
-        renderMetadata,
-    });
-    const chunkCount = outputFile
-        ? (_g = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.totalChunks) !== null && _g !== void 0 ? _g : 0
-        : chunks.length / chunkMultiplier;
-    const availableChunks = chunks.map((c) => (0, parse_chunk_key_1.parseLambdaChunkKey)(c.Key));
+    const chunkCount = (_f = overallProgress.chunks.length) !== null && _f !== void 0 ? _f : 0;
     const missingChunks = renderMetadata
         ? new Array(renderMetadata.totalChunks)
             .fill(true)
             .map((_, i) => i)
             .filter((index) => {
-            return !availableChunks.find((c) => c.chunk === index);
+            var _a;
+            return !((_a = overallProgress.chunks) !== null && _a !== void 0 ? _a : []).find((c) => c === index);
         })
         : null;
     // We add a 20 second buffer for it, since AWS timeshifts can be quite a lot. Once it's 20sec over the limit, we consider it timed out
@@ -206,7 +130,6 @@ const getProgress = async ({ bucketName, renderId, expectedBucketOwner, region,
             ? (0, make_timeout_error_1.makeTimeoutError)({
                 timeoutInMilliseconds,
                 renderMetadata,
-                chunks,
                 renderId,
                 missingChunks: missingChunks !== null && missingChunks !== void 0 ? missingChunks : [],
             })
@@ -214,57 +137,58 @@ const getProgress = async ({ bucketName, renderId, expectedBucketOwner, region,
         ...errorExplanations,
     ].filter(no_react_1.NoReactInternals.truthy);
     return {
-        framesRendered,
+        framesRendered: (_g = overallProgress.framesRendered) !== null && _g !== void 0 ? _g : 0,
         chunks: chunkCount,
         done: false,
-        encodingStatus,
+        encodingStatus: {
+            framesEncoded: overallProgress.framesEncoded,
+            combinedFrames: overallProgress.combinedFrames,
+            timeToCombine: overallProgress.timeToCombine,
+        },
+        timeToRenderFrames: overallProgress.timeToRenderFrames,
         costs: priceFromBucket
             ? (0, format_costs_info_1.formatCostsInfo)(priceFromBucket.accruedSoFar)
             : (0, format_costs_info_1.formatCostsInfo)(0),
         renderId,
         renderMetadata,
         bucket: bucketName,
-        outputFile: (_h = outputFile === null || outputFile === void 0 ? void 0 : outputFile.url) !== null && _h !== void 0 ? _h : null,
-        timeToFinish,
+        outputFile: null,
+        timeToFinish: null,
         errors: allErrors,
         fatalErrorEncountered: allErrors.some((f) => f.isFatal && !f.willRetry),
         currentTime: Date.now(),
-        renderSize,
-        lambdasInvoked: lambdasInvokedStats.lambdasInvoked,
+        renderSize: 0,
+        lambdasInvoked: (_h = overallProgress.lambdasInvoked) !== null && _h !== void 0 ? _h : 0,
         cleanup,
-        timeToFinishChunks: allChunks
+        timeToFinishChunks: allChunks && overallProgress
             ? (0, calculate_chunk_times_1.calculateChunkTimes)({
-                contents,
-                renderId,
                 type: 'absolute-time',
+                timings: overallProgress.timings,
             })
             : null,
         overallProgress: (0, get_overall_progress_1.getOverallProgress)({
-            cleanup: cleanup ? cleanup.filesDeleted / cleanup.minFilesToDelete : 0,
-            encoding: finalEncodingStatus && renderMetadata && frameCount
-                ? finalEncodingStatus.framesEncoded / frameCount
+            encoding: renderMetadata && frameCount
+                ? ((_j = overallProgress.framesEncoded) !== null && _j !== void 0 ? _j : 0) / frameCount
                 : 0,
             invoking: renderMetadata
-                ? lambdasInvokedStats.lambdasInvoked /
+                ? ((_k = overallProgress.lambdasInvoked) !== null && _k !== void 0 ? _k : 0) /
                     renderMetadata.estimatedRenderLambdaInvokations
                 : 0,
             rendering: renderMetadata ? chunkCount / renderMetadata.totalChunks : 0,
-            frames: frameCount === null ? 0 : framesRendered / frameCount,
+            frames: ((_l = overallProgress.framesRendered) !== null && _l !== void 0 ? _l : 0) / (frameCount !== null && frameCount !== void 0 ? frameCount : 1),
         }),
-        retriesInfo,
-        outKey: outputFile && renderMetadata
-            ? (0, expected_out_name_1.getExpectedOutName)(renderMetadata, bucketName, customCredentials).key
-            : null,
-        outBucket: outputFile && renderMetadata
-            ? (0, expected_out_name_1.getExpectedOutName)(renderMetadata, bucketName, customCredentials)
-                .renderBucketName
-            : null,
+        retriesInfo: (_m = overallProgress.retries) !== null && _m !== void 0 ? _m : [],
+        outKey: null,
+        outBucket: null,
         mostExpensiveFrameRanges: null,
-        timeToEncode: null,
-        outputSizeInBytes: (_j = outputFile === null || outputFile === void 0 ? void 0 : outputFile.size) !== null && _j !== void 0 ? _j : null,
+        timeToEncode: overallProgress.timeToEncode,
+        outputSizeInBytes: null,
         estimatedBillingDurationInMilliseconds: priceFromBucket
             ? priceFromBucket.estimatedBillingDurationInMilliseconds
             : null,
+        combinedFrames: (_o = overallProgress.combinedFrames) !== null && _o !== void 0 ? _o : 0,
+        timeToCombine: (_p = overallProgress.timeToCombine) !== null && _p !== void 0 ? _p : null,
+        timeoutTimestamp: overallProgress.timeoutTimestamp,
         type: 'success',
     };
 };

package/dist/functions/helpers/get-retry-stats.d.ts

@@ -1,10 +1,5 @@
-import type { _Object } from '@aws-sdk/client-s3';
 export type ChunkRetry = {
     chunk: number;
     attempt: number;
     time: number;
 };
-export declare const getRetryStats: ({ contents, renderId, }: {
-    contents: _Object[];
-    renderId: string;
-}) => ChunkRetry[];

package/dist/functions/helpers/get-retry-stats.js

@@ -1,20 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRetryStats = void 0;
-const constants_1 = require("../../shared/constants");
-const parse_lambda_initialized_key_1 = require("../../shared/parse-lambda-initialized-key");
-const getRetryStats = ({ contents, renderId, }) => {
-    const retries = contents
-        .filter((c) => { var _a; return (_a = c.Key) === null || _a === void 0 ? void 0 : _a.startsWith((0, constants_1.lambdaChunkInitializedPrefix)(renderId)); })
-        .filter((c) => (0, parse_lambda_initialized_key_1.parseLambdaInitializedKey)(c.Key).attempt !== 1);
-    return retries.map((retry) => {
-        var _a;
-        const parsed = (0, parse_lambda_initialized_key_1.parseLambdaInitializedKey)(retry.Key);
-        return {
-            chunk: parsed.chunk,
-            attempt: parsed.attempt,
-            time: (_a = retry.LastModified) === null || _a === void 0 ? void 0 : _a.getTime(),
-        };
-    });
-};
-exports.getRetryStats = getRetryStats;

package/dist/functions/helpers/inspect-errors.d.ts

@@ -1,10 +1,4 @@
-import type { _Object } from '@aws-sdk/client-s3';
-import type { AwsRegion } from '../../pricing/aws-regions';
-import type { EnhancedErrorInfo } from './write-lambda-error';
-export declare const inspectErrors: ({ contents, bucket, region, renderId, expectedBucketOwner, }: {
-    contents: _Object[];
-    bucket: string;
-    region: AwsRegion;
-    renderId: string;
-    expectedBucketOwner: string;
-}) => Promise<EnhancedErrorInfo[]>;
+import type { EnhancedErrorInfo, LambdaErrorInfo } from './write-lambda-error';
+export declare const inspectErrors: ({ errors, }: {
+    errors: LambdaErrorInfo[];
+}) => EnhancedErrorInfo[];

package/dist/functions/helpers/inspect-errors.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.inspectErrors = void 0;
-const no_react_1 = require("remotion/no-react");
-const constants_1 = require("../../shared/constants");
 const docs_url_1 = require("../../shared/docs-url");
-const stream_to_string_1 = require("../../shared/stream-to-string");
-const io_1 = require("./io");
 const is_enosp_err_1 = require("./is-enosp-err");
 const FAILED_TO_LAUNCH_TOKEN = 'Failed to launch browser.';
 const getExplanation = (stack) => {
@@ -31,30 +27,12 @@ const getExplanation = (stack) => {
     }
     return null;
 };
-const inspectErrors = async ({ contents, bucket, region, renderId, expectedBucketOwner, }) => {
-    const errs = contents
-        .filter((c) => { var _a; return (_a = c.Key) === null || _a === void 0 ? void 0 : _a.startsWith((0, constants_1.getErrorKeyPrefix)(renderId)); })
-        .map((c) => c.Key)
-        .filter(no_react_1.NoReactInternals.truthy);
-    if (errs.length === 0) {
-        return [];
-    }
-    const errors = await Promise.all(errs.map(async (key) => {
-        const Body = await (0, io_1.lambdaReadFile)({
-            bucketName: bucket,
-            key,
-            region,
-            expectedBucketOwner,
-        });
-        const errorLog = await (0, stream_to_string_1.streamToString)(Body);
-        return errorLog;
-    }));
-    return errors.map((e, index) => {
-        const parsed = JSON.parse(e);
+const inspectErrors = ({ errors, }) => {
+    return errors.map((e) => {
         return {
-            ...parsed,
-            explanation: getExplanation(parsed.stack),
-            s3Location: errs[index],
+            ...e,
+            explanation: getExplanation(e.stack),
+            s3Location: '',
         };
     });
 };

package/dist/functions/helpers/io.d.ts

@@ -32,7 +32,6 @@ type LambdaWriteFileInput = {
     downloadBehavior: DownloadBehavior | null;
     customCredentials: CustomCredentials | null;
 };
-export declare const tryLambdaWriteFile: ({ bucketName, key, body, region, privacy, expectedBucketOwner, downloadBehavior, customCredentials, }: LambdaWriteFileInput) => Promise<void>;
 export declare const lambdaWriteFile: (params: LambdaWriteFileInput & {
     retries?: number;
 }) => Promise<void>;

package/dist/functions/helpers/io.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lambdaHeadCommand = exports.lambdaReadFile = exports.lambdaWriteFile = exports.tryLambdaWriteFile = exports.lambdaDeleteFile = exports.lambdaLs = void 0;
+exports.lambdaHeadCommand = exports.lambdaReadFile = exports.lambdaWriteFile = exports.lambdaDeleteFile = exports.lambdaLs = void 0;
 const client_s3_1 = require("@aws-sdk/client-s3");
 const mime_types_1 = __importDefault(require("mime-types"));
 const aws_clients_1 = require("../../shared/aws-clients");
@@ -71,12 +71,11 @@ const tryLambdaWriteFile = async ({ bucketName, key, body, region, privacy, expe
         ContentDisposition: (0, content_disposition_header_1.getContentDispositionHeader)(downloadBehavior),
     }));
 };
-exports.tryLambdaWriteFile = tryLambdaWriteFile;
 const lambdaWriteFile = async (params) => {
     var _a;
     const remainingRetries = (_a = params.retries) !== null && _a !== void 0 ? _a : 2;
     try {
-        await (0, exports.tryLambdaWriteFile)(params);
+        await tryLambdaWriteFile(params);
     }
     catch (err) {
         if (remainingRetries === 0) {

package/dist/functions/helpers/lifecycle.d.ts

@@ -6,10 +6,6 @@ declare const expiryDays: {
     readonly '30-days': 30;
 };
 export type DeleteAfter = keyof typeof expiryDays;
-export declare const getEnabledLifeCycleRule: ({ key, value, }: {
-    key: string;
-    value: number;
-}) => LifecycleRule;
 export declare const getLifeCycleRules: () => LifecycleRule[];
 export declare const generateRandomHashWithLifeCycleRule: (deleteAfter: DeleteAfter | null) => string;
 export declare const validateDeleteAfter: (lifeCycleValue: unknown) => void;

package/dist/functions/helpers/lifecycle.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDeleteAfter = exports.generateRandomHashWithLifeCycleRule = exports.getLifeCycleRules = exports.getEnabledLifeCycleRule = void 0;
+exports.validateDeleteAfter = exports.generateRandomHashWithLifeCycleRule = exports.getLifeCycleRules = void 0;
 const random_hash_1 = require("../../shared/random-hash");
 const truthy_1 = require("../../shared/truthy");
 // Needs to be in sync with renderer/src/options/delete-after.ts#L7
@@ -22,9 +22,8 @@ const getEnabledLifeCycleRule = ({ key, value, }) => {
         Status: 'Enabled',
     };
 };
-exports.getEnabledLifeCycleRule = getEnabledLifeCycleRule;
 const getLifeCycleRules = () => {
-    return Object.entries(expiryDays).map(([key, value]) => (0, exports.getEnabledLifeCycleRule)({ key, value }));
+    return Object.entries(expiryDays).map(([key, value]) => getEnabledLifeCycleRule({ key, value }));
 };
 exports.getLifeCycleRules = getLifeCycleRules;
 const generateRandomHashWithLifeCycleRule = (deleteAfter) => {

package/dist/functions/helpers/make-timeout-error.d.ts

@@ -1,9 +1,7 @@
-import type { _Object } from '@aws-sdk/client-s3';
 import type { RenderMetadata } from '../../defaults';
 import type { EnhancedErrorInfo } from './write-lambda-error';
 export declare const makeTimeoutError: ({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, }: {
     timeoutInMilliseconds: number;
-    chunks: _Object[];
     renderMetadata: RenderMetadata;
     renderId: string;
     missingChunks: number[];

package/dist/functions/helpers/merge-chunks.d.ts

@@ -3,12 +3,7 @@ import type { CustomCredentials } from '../../shared/aws-clients';
 import type { PostRenderData, Privacy, RenderMetadata, SerializedInputProps } from '../../shared/constants';
 import type { DownloadBehavior } from '../../shared/content-disposition-header';
 import type { LambdaCodec } from '../../shared/validate-lambda-codec';
-export type OnAllChunksAvailable = (options: {
-    inputProps: SerializedInputProps;
-    serializedResolvedProps: SerializedInputProps;
-    framesPerLambda: number;
-    compositionStart: number;
-}) => void;
+import type { OverallProgressHelper } from './overall-render-progress';
 export declare const mergeChunksAndFinishRender: (options: {
     bucketName: string;
     renderId: string;
@@ -27,11 +22,14 @@ export declare const mergeChunksAndFinishRender: (options: {
     inputProps: SerializedInputProps;
     serializedResolvedProps: SerializedInputProps;
     renderMetadata: RenderMetadata;
-    onAllChunks: OnAllChunksAvailable;
     audioBitrate: string | null;
     logLevel: LogLevel;
     framesPerLambda: number;
     binariesDirectory: string | null;
     preferLossless: boolean;
     compositionStart: number;
+    outdir: string;
+    files: string[];
+    overallProgress: OverallProgressHelper;
+    startTime: number;
 }) => Promise<PostRenderData>;