@remotion/serverless 4.0.244 → 4.0.245

package/dist/progress.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgress = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+const no_react_1 = require("remotion/no-react");
+const calculate_chunk_times_1 = require("./calculate-chunk-times");
+const estimate_price_from_bucket_1 = require("./estimate-price-from-bucket");
+const expected_out_name_1 = require("./expected-out-name");
+const format_costs_info_1 = require("./format-costs-info");
+const get_overall_progress_1 = require("./get-overall-progress");
+const get_overall_progress_from_storage_1 = require("./get-overall-progress-from-storage");
+const inspect_error_1 = require("./inspect-error");
+const make_timeout_error_1 = require("./make-timeout-error");
+const render_has_audio_video_1 = require("./render-has-audio-video");
+const truthy_1 = require("./truthy");
+const getProgress = async ({ bucketName, renderId, expectedBucketOwner, region, memorySizeInMb, timeoutInMilliseconds, customCredentials, providerSpecifics, forcePathStyle, functionName, }) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u;
+    const overallProgress = await (0, get_overall_progress_from_storage_1.getOverallProgressFromStorage)({
+        renderId,
+        bucketName,
+        expectedBucketOwner,
+        region,
+        providerSpecifics,
+        forcePathStyle,
+    });
+    if (overallProgress.postRenderData) {
+        if (!overallProgress.renderMetadata) {
+            throw new Error('No render metadata found even though render is finished');
+        }
+        if (overallProgress.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! 😉");
+        }
+        const outData = (0, expected_out_name_1.getExpectedOutName)(overallProgress.renderMetadata, bucketName, customCredentials);
+        const totalFrameCount = pure_1.NoReactAPIs.getFramesToRender(overallProgress.renderMetadata.frameRange, overallProgress.renderMetadata.everyNthFrame).length;
+        return {
+            framesRendered: totalFrameCount,
+            bucket: bucketName,
+            renderSize: overallProgress.postRenderData.renderSize,
+            chunks: overallProgress.renderMetadata.totalChunks,
+            cleanup: {
+                doneIn: overallProgress.postRenderData.timeToCleanUp,
+                filesDeleted: overallProgress.postRenderData.filesCleanedUp,
+                minFilesToDelete: overallProgress.postRenderData.filesCleanedUp,
+            },
+            costs: {
+                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: overallProgress.postRenderData.errors,
+            fatalErrorEncountered: false,
+            lambdasInvoked: overallProgress.renderMetadata.totalChunks,
+            outputFile: overallProgress.postRenderData.outputFile,
+            renderId,
+            timeToFinish: overallProgress.postRenderData.timeToFinish,
+            timeToFinishChunks: overallProgress.postRenderData.timeToRenderChunks,
+            timeToRenderFrames: overallProgress.postRenderData.timeToRenderFrames,
+            overallProgress: 1,
+            retriesInfo: overallProgress.postRenderData.retriesInfo,
+            outKey: outData.key,
+            outBucket: outData.renderBucketName,
+            mostExpensiveFrameRanges: (_a = overallProgress.postRenderData.mostExpensiveFrameRanges) !== null && _a !== void 0 ? _a : null,
+            timeToEncode: overallProgress.postRenderData.timeToEncode,
+            outputSizeInBytes: overallProgress.postRenderData.outputSize,
+            type: 'success',
+            estimatedBillingDurationInMilliseconds: overallProgress.postRenderData.estimatedBillingDurationInMilliseconds,
+            timeToCombine: overallProgress.postRenderData.timeToCombine,
+            combinedFrames: totalFrameCount,
+            renderMetadata: overallProgress.renderMetadata,
+            timeoutTimestamp: overallProgress.timeoutTimestamp,
+            compositionValidated: overallProgress.compositionValidated,
+            functionLaunched: overallProgress.functionLaunched,
+            serveUrlOpened: overallProgress.serveUrlOpened,
+            artifacts: overallProgress.receivedArtifact,
+        };
+    }
+    const { renderMetadata } = overallProgress;
+    const errorExplanations = (0, inspect_error_1.inspectErrors)({
+        errors: overallProgress.errors,
+    });
+    const { hasAudio, hasVideo } = renderMetadata
+        ? (0, render_has_audio_video_1.lambdaRenderHasAudioVideo)(renderMetadata)
+        : { hasAudio: false, hasVideo: false };
+    const chunkCount = (_b = overallProgress.chunks.length) !== null && _b !== void 0 ? _b : 0;
+    const cleanup = {
+        doneIn: null,
+        minFilesToDelete: 0,
+        filesDeleted: 0,
+    };
+    if (renderMetadata === null) {
+        return {
+            framesRendered: (_c = overallProgress.framesRendered) !== null && _c !== void 0 ? _c : 0,
+            chunks: chunkCount,
+            done: false,
+            encodingStatus: {
+                framesEncoded: overallProgress.framesEncoded,
+                combinedFrames: overallProgress.combinedFrames,
+                timeToCombine: overallProgress.timeToCombine,
+            },
+            timeToRenderFrames: overallProgress.timeToRenderFrames,
+            costs: (0, format_costs_info_1.formatCostsInfo)(0),
+            renderId,
+            renderMetadata,
+            bucket: bucketName,
+            outputFile: null,
+            timeToFinish: null,
+            errors: errorExplanations,
+            fatalErrorEncountered: errorExplanations.some((f) => f.isFatal && !f.willRetry),
+            currentTime: Date.now(),
+            renderSize: 0,
+            lambdasInvoked: (_d = overallProgress.lambdasInvoked) !== null && _d !== void 0 ? _d : 0,
+            cleanup,
+            timeToFinishChunks: null,
+            overallProgress: (0, get_overall_progress_1.getOverallProgress)({
+                encoding: 0,
+                invoking: 0,
+                frames: 0,
+                gotComposition: overallProgress.compositionValidated,
+                visitedServeUrl: overallProgress.serveUrlOpened,
+                invokedLambda: overallProgress.lambdasInvoked,
+                combining: 0,
+            }),
+            retriesInfo: (_e = overallProgress.retries) !== null && _e !== void 0 ? _e : [],
+            outKey: null,
+            outBucket: null,
+            mostExpensiveFrameRanges: null,
+            timeToEncode: overallProgress.timeToEncode,
+            outputSizeInBytes: null,
+            estimatedBillingDurationInMilliseconds: null,
+            combinedFrames: (_f = overallProgress.combinedFrames) !== null && _f !== void 0 ? _f : 0,
+            timeToCombine: (_g = overallProgress.timeToCombine) !== null && _g !== void 0 ? _g : null,
+            timeoutTimestamp: overallProgress.timeoutTimestamp,
+            type: 'success',
+            compositionValidated: overallProgress.compositionValidated,
+            functionLaunched: overallProgress.functionLaunched,
+            serveUrlOpened: overallProgress.serveUrlOpened,
+            artifacts: overallProgress.receivedArtifact,
+        };
+    }
+    const priceFromBucket = (0, estimate_price_from_bucket_1.estimatePriceFromBucket)({
+        renderMetadata,
+        memorySizeInMb,
+        lambdasInvoked: (_h = renderMetadata.estimatedRenderLambdaInvokations) !== null && _h !== void 0 ? _h : 0,
+        diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+        timings: (_j = overallProgress.timings) !== null && _j !== void 0 ? _j : [],
+        region,
+        providerSpecifics,
+    });
+    const chunkMultiplier = [hasAudio, hasVideo].filter(truthy_1.truthy).length;
+    if (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! 😉");
+    }
+    const allChunks = ((_k = overallProgress.chunks) !== null && _k !== void 0 ? _k : []).length / chunkMultiplier ===
+        ((_l = renderMetadata.totalChunks) !== null && _l !== void 0 ? _l : Infinity);
+    const frameCount = pure_1.NoReactAPIs.getFramesToRender(renderMetadata.frameRange, renderMetadata.everyNthFrame).length;
+    const missingChunks = new Array(renderMetadata.totalChunks)
+        .fill(true)
+        .map((_, i) => i)
+        .filter((index) => {
+        var _a;
+        return (typeof ((_a = overallProgress.chunks) !== null && _a !== void 0 ? _a : []).find((c) => c === index) ===
+            'undefined');
+    });
+    // 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
+    // 1. If we have missing chunks, we consider it timed out
+    const isBeyondTimeoutAndMissingChunks = Date.now() > renderMetadata.startedDate + timeoutInMilliseconds + 20000 &&
+        missingChunks &&
+        missingChunks.length > 0;
+    // 2. If we have no missing chunks, but the encoding is not done, even after the additional `merge` function has been spawned, we consider it timed out
+    const isBeyondTimeoutAndHasStitchTimeout = Date.now() > renderMetadata.startedDate + timeoutInMilliseconds * 2 + 20000;
+    const allErrors = [
+        isBeyondTimeoutAndMissingChunks || isBeyondTimeoutAndHasStitchTimeout
+            ? (0, make_timeout_error_1.makeTimeoutError)({
+                timeoutInMilliseconds,
+                renderMetadata,
+                renderId,
+                missingChunks: missingChunks !== null && missingChunks !== void 0 ? missingChunks : [],
+                region,
+                functionName,
+                providerSpecifics,
+            })
+            : null,
+        ...errorExplanations,
+    ].filter(no_react_1.NoReactInternals.truthy);
+    return {
+        framesRendered: (_m = overallProgress.framesRendered) !== null && _m !== void 0 ? _m : 0,
+        chunks: chunkCount,
+        done: false,
+        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: null,
+        timeToFinish: null,
+        errors: allErrors,
+        fatalErrorEncountered: allErrors.some((f) => f.isFatal && !f.willRetry),
+        currentTime: Date.now(),
+        renderSize: 0,
+        lambdasInvoked: (_o = overallProgress.lambdasInvoked) !== null && _o !== void 0 ? _o : 0,
+        cleanup,
+        timeToFinishChunks: allChunks && overallProgress
+            ? (0, calculate_chunk_times_1.calculateChunkTimes)({
+                type: 'absolute-time',
+                timings: overallProgress.timings,
+            })
+            : null,
+        overallProgress: (0, get_overall_progress_1.getOverallProgress)({
+            encoding: frameCount
+                ? ((_p = overallProgress.framesEncoded) !== null && _p !== void 0 ? _p : 0) / frameCount
+                : 0,
+            invoking: ((_q = overallProgress.lambdasInvoked) !== null && _q !== void 0 ? _q : 0) /
+                renderMetadata.estimatedRenderLambdaInvokations,
+            frames: ((_r = overallProgress.framesRendered) !== null && _r !== void 0 ? _r : 0) / (frameCount !== null && frameCount !== void 0 ? frameCount : 1),
+            gotComposition: overallProgress.compositionValidated,
+            visitedServeUrl: overallProgress.serveUrlOpened,
+            invokedLambda: overallProgress.lambdasInvoked,
+            combining: overallProgress.combinedFrames / (frameCount !== null && frameCount !== void 0 ? frameCount : 1),
+        }),
+        retriesInfo: (_s = overallProgress.retries) !== null && _s !== void 0 ? _s : [],
+        outKey: null,
+        outBucket: null,
+        mostExpensiveFrameRanges: null,
+        timeToEncode: overallProgress.timeToEncode,
+        outputSizeInBytes: null,
+        estimatedBillingDurationInMilliseconds: priceFromBucket
+            ? priceFromBucket.estimatedBillingDurationInMilliseconds
+            : null,
+        combinedFrames: (_t = overallProgress.combinedFrames) !== null && _t !== void 0 ? _t : 0,
+        timeToCombine: (_u = overallProgress.timeToCombine) !== null && _u !== void 0 ? _u : null,
+        timeoutTimestamp: overallProgress.timeoutTimestamp,
+        type: 'success',
+        compositionValidated: overallProgress.compositionValidated,
+        functionLaunched: overallProgress.functionLaunched,
+        serveUrlOpened: overallProgress.serveUrlOpened,
+        artifacts: overallProgress.receivedArtifact,
+    };
+};
+exports.getProgress = getProgress;

package/dist/render-has-audio-video.d.ts

@@ -0,0 +1,6 @@
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+export declare const lambdaRenderHasAudioVideo: <Provider extends CloudProvider>(renderMetadata: RenderMetadata<Provider>) => {
+    hasAudio: boolean;
+    hasVideo: boolean;
+};

package/dist/render-has-audio-video.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lambdaRenderHasAudioVideo = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+const lambdaRenderHasAudioVideo = (renderMetadata) => {
+    if (renderMetadata.type === 'still') {
+        throw new Error('Cannot merge stills');
+    }
+    const support = pure_1.NoReactAPIs.codecSupportsMedia(renderMetadata.codec);
+    const hasVideo = renderMetadata
+        ? !pure_1.NoReactAPIs.isAudioCodec(renderMetadata.codec)
+        : false;
+    const hasAudio = renderMetadata
+        ? !renderMetadata.muted && support.audio
+        : false;
+    return {
+        hasAudio,
+        hasVideo,
+    };
+};
+exports.lambdaRenderHasAudioVideo = lambdaRenderHasAudioVideo;

package/dist/render-progress.d.ts

@@ -0,0 +1,51 @@
+import type { ExpensiveChunk } from './most-expensive-chunks';
+import type { RenderMetadata } from './render-metadata';
+import type { ChunkRetry, CloudProvider, CostsInfo, ReceivedArtifact } from './types';
+import type { EnhancedErrorInfo } from './write-lambda-error';
+export type CleanupInfo = {
+    doneIn: number | null;
+    minFilesToDelete: number;
+    filesDeleted: number;
+};
+type EncodingProgress = {
+    framesEncoded: number;
+    combinedFrames: number;
+    timeToCombine: number | null;
+};
+export type GenericRenderProgress<Provider extends CloudProvider> = {
+    chunks: number;
+    done: boolean;
+    encodingStatus: EncodingProgress | null;
+    costs: CostsInfo;
+    renderId: string;
+    renderMetadata: RenderMetadata<Provider> | null;
+    bucket: string;
+    outputFile: string | null;
+    outKey: string | null;
+    outBucket: string | null;
+    timeToFinish: number | null;
+    errors: EnhancedErrorInfo[];
+    fatalErrorEncountered: boolean;
+    currentTime: number;
+    renderSize: number;
+    lambdasInvoked: number;
+    cleanup: CleanupInfo | null;
+    timeToFinishChunks: number | null;
+    timeToRenderFrames: number | null;
+    timeToEncode: number | null;
+    overallProgress: number;
+    retriesInfo: ChunkRetry[];
+    mostExpensiveFrameRanges: ExpensiveChunk[] | null;
+    framesRendered: number;
+    outputSizeInBytes: number | null;
+    type: 'success';
+    estimatedBillingDurationInMilliseconds: number | null;
+    combinedFrames: number;
+    timeToCombine: number | null;
+    timeoutTimestamp: number;
+    functionLaunched: number;
+    serveUrlOpened: number | null;
+    compositionValidated: number | null;
+    artifacts: ReceivedArtifact<Provider>[];
+};
+export {};

package/dist/render-progress.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/return-values.d.ts

@@ -0,0 +1,38 @@
+import type { VideoConfig } from 'remotion/no-react';
+import type { ServerlessRoutines } from './constants';
+import type { GenericRenderProgress } from './render-progress';
+import type { CloudProvider } from './types';
+export type OrError<T> = T | {
+    type: 'error';
+    message: string;
+    stack: string;
+};
+export interface ServerlessReturnValues<Provider extends CloudProvider> {
+    [ServerlessRoutines.start]: Promise<{
+        type: 'success';
+        bucketName: string;
+        renderId: string;
+    }>;
+    [ServerlessRoutines.launch]: Promise<{
+        type: 'success';
+    }>;
+    [ServerlessRoutines.renderer]: Promise<{
+        type: 'success';
+    }>;
+    [ServerlessRoutines.status]: Promise<GenericRenderProgress<Provider>>;
+    [ServerlessRoutines.info]: {
+        version: string;
+        type: 'success';
+    };
+    [ServerlessRoutines.still]: Promise<{
+        type: 'success';
+    } | {
+        type: 'error';
+        message: string;
+        stack: string;
+    }>;
+    [ServerlessRoutines.compositions]: Promise<{
+        compositions: VideoConfig[];
+        type: 'success';
+    }>;
+}

package/dist/return-values.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/stackback.d.ts

@@ -0,0 +1,6 @@
+export declare const stackback: (error: Error) => NodeJS.CallSite[];
+declare global {
+    interface Error {
+        _sb_callsites: NodeJS.CallSite[];
+    }
+}

package/dist/stackback.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stackback = void 0;
+function FormatStackTrace(error, frames) {
+    const lines = [];
+    try {
+        lines.push(error.toString());
+    }
+    catch (e) {
+        try {
+            lines.push('<error: ' + e + '>');
+        }
+        catch (_a) {
+            lines.push('<error>');
+        }
+    }
+    for (let i = 0; i < frames.length; i++) {
+        const frame = frames[i];
+        let line;
+        try {
+            line = frame.toString();
+        }
+        catch (e) {
+            try {
+                line = '<error: ' + e + '>';
+            }
+            catch (_b) {
+                // Any code that reaches this point is seriously nasty!
+                line = '<error>';
+            }
+        }
+        lines.push('    at ' + line);
+    }
+    return lines.join('\n');
+}
+const stackback = (error) => {
+    // save original stacktrace
+    const save = Error.prepareStackTrace;
+    // replace capture with our function
+    Error.prepareStackTrace = function (err, trace) {
+        // cache stack frames so we don't have to get them again
+        // use a non-enumerable property
+        Object.defineProperty(err, '_sb_callsites', {
+            value: trace,
+        });
+        return (save || FormatStackTrace)(err, trace);
+    };
+    // force capture of the stack frames
+    // eslint-disable-next-line no-unused-expressions
+    error.stack;
+    // someone already asked for the stack so we can't do this trick
+    if (!error._sb_callsites) {
+        return [];
+    }
+    // return original capture function
+    Error.prepareStackTrace = save;
+    return error._sb_callsites;
+};
+exports.stackback = stackback;

package/dist/stream-renderer.d.ts

@@ -0,0 +1,17 @@
+import type { EmittedArtifact, LogLevel } from '@remotion/renderer';
+import type { ServerlessPayload } from './constants';
+import type { OverallProgressHelper } from './overall-render-progress';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './types';
+export declare const streamRendererFunctionWithRetry: <Provider extends CloudProvider>({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, }: {
+    payload: ServerlessPayload<Provider>;
+    functionName: string;
+    outdir: string;
+    overallProgress: OverallProgressHelper<Provider>;
+    files: string[];
+    logLevel: LogLevel;
+    onArtifact: (asset: EmittedArtifact) => {
+        alreadyExisted: boolean;
+    };
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => Promise<unknown>;

package/dist/stream-renderer.js

@@ -0,0 +1,148 @@
+"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 constants_1 = require("./constants");
+const serialize_artifact_1 = require("./serialize-artifact");
+const streamRenderer = ({ payload, functionName, outdir, overallProgress, files, logLevel, onArtifact, providerSpecifics, }) => {
+    if (payload.type !== constants_1.ServerlessRoutines.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);
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Received video chunk for chunk ${payload.chunk}`);
+                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);
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Received audio chunk for chunk ${payload.chunk}`);
+                files.push(filename);
+                return;
+            }
+            if (message.type === 'chunk-complete') {
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Finished chunk ${payload.chunk}`);
+                overallProgress.addChunkCompleted(payload.chunk, message.payload.start, message.payload.rendered);
+                return;
+            }
+            if (message.type === 'artifact-emitted') {
+                const artifact = (0, serialize_artifact_1.deserializeArtifact)(message.payload.artifact);
+                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Received artifact on frame ${message.payload.artifact.frame}:`, artifact.filename, artifact.content.length + 'bytes.');
+                const { alreadyExisted } = onArtifact(artifact);
+                if (alreadyExisted) {
+                    return resolve({
+                        type: 'error',
+                        error: `Chunk ${payload.chunk} emitted an asset filename ${message.payload.artifact.filename} at frame ${message.payload.artifact.frame} but there is already another artifact with the same name. https://remotion.dev/docs/artifacts`,
+                        shouldRetry: false,
+                    });
+                }
+                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}`);
+        };
+        providerSpecifics
+            .callFunctionStreaming({
+            functionName,
+            payload,
+            retriesRemaining: 1,
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            timeoutInTest: 12000,
+            type: constants_1.ServerlessRoutines.renderer,
+            receivedStreamingPayload,
+        })
+            .then(() => {
+            resolve({
+                type: 'success',
+            });
+        })
+            .catch((err) => {
+            var _a, _b;
+            const shouldRetry = (_b = (_a = err.stack) === null || _a === void 0 ? void 0 : _a.includes('Error: aborted')) !== null && _b !== void 0 ? _b : false;
+            resolve({
+                type: 'error',
+                error: err.stack,
+                shouldRetry,
+            });
+        });
+    });
+};
+const streamRendererFunctionWithRetry = async ({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, }) => {
+    if (payload.type !== constants_1.ServerlessRoutines.renderer) {
+        throw new Error('Expected renderer type');
+    }
+    const result = await streamRenderer({
+        files,
+        functionName,
+        outdir,
+        overallProgress,
+        payload,
+        logLevel,
+        onArtifact,
+        providerSpecifics,
+    });
+    if (result.type === 'error') {
+        if (!result.shouldRetry) {
+            throw new Error(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,
+            onArtifact,
+            providerSpecifics,
+        });
+    }
+};
+exports.streamRendererFunctionWithRetry = streamRendererFunctionWithRetry;

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+import type { ServerlessPayloads, ServerlessRoutines } from './constants';
+export interface CloudProvider<Region extends string = string, ReceivedArtifactType extends Record<string, unknown> = Record<string, unknown>> {
+    type: string;
+    region: Region;
+    receivedArtifactType: ReceivedArtifactType;
+}
+export type ReceivedArtifact<Provider extends CloudProvider> = {
+    filename: string;
+    sizeInBytes: number;
+    s3Url: string;
+    s3Key: string;
+} & Provider['receivedArtifactType'];
+export type CostsInfo = {
+    accruedSoFar: number;
+    displayCost: string;
+    currency: string;
+    disclaimer: string;
+};
+export type RenderStillLambdaResponsePayload<Provider extends CloudProvider> = {
+    type: 'success';
+    output: string;
+    outKey: string;
+    size: number;
+    bucketName: string;
+    sizeInBytes: number;
+    estimatedPrice: CostsInfo;
+    renderId: string;
+    receivedArtifacts: ReceivedArtifact<Provider>[];
+};
+export type ChunkRetry = {
+    chunk: number;
+    attempt: number;
+    time: number;
+};
+export type ParsedTiming = {
+    chunk: number;
+    start: number;
+    rendered: number;
+};
+export type CallFunctionOptions<T extends ServerlessRoutines, Provider extends CloudProvider> = {
+    functionName: string;
+    type: T;
+    payload: ServerlessPayloads<Provider>[T];
+    region: Provider['region'];
+    timeoutInTest: number;
+};
+export type ObjectChunkTimingData = {
+    chunk: number;
+    frameRange: [number, number];
+    startDate: number;
+    timings: {
+        [key: number]: number;
+    };
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validate-download-behavior.d.ts

@@ -0,0 +1 @@
+export declare const validateDownloadBehavior: (downloadBehavior: unknown) => null | undefined;