@remotion/serverless-client 4.0.261

package/dist/make-timeout-message.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+export declare const makeTimeoutMessage: <Provider extends CloudProvider>({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, providerSpecifics, }: {
+    timeoutInMilliseconds: number;
+    missingChunks: number[];
+    renderMetadata: RenderMetadata<Provider>;
+    renderId: string;
+    region: Provider["region"];
+    functionName: string;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => string;

package/dist/make-timeout-message.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTimeoutMessage = void 0;
+const constants_1 = require("./constants");
+const docs_url_1 = require("./docs-url");
+const MAX_MISSING_CHUNKS = 5;
+const makeChunkMissingMessage = ({ missingChunks, renderMetadata, region, providerSpecifics, functionName, }) => {
+    if (missingChunks.length === 0) {
+        return 'All chunks have been successfully rendered, but the main function has timed out.';
+    }
+    return [
+        `The following chunks are missing (showing ${Math.min(MAX_MISSING_CHUNKS, missingChunks.length)} out of ${missingChunks.length}):`,
+        ...missingChunks
+            .map((ch) => {
+            const isLastChunk = ch === renderMetadata.totalChunks - 1;
+            const start = ch * renderMetadata.framesPerLambda;
+            const end = renderMetadata.type === 'still'
+                ? 0
+                : isLastChunk
+                    ? renderMetadata.frameRange[1]
+                    : (ch + 1) * renderMetadata.framesPerLambda - 1;
+            const msg = `Chunk ${ch} (Frames ${start} - ${end})`;
+            return [
+                msg,
+                `▸ Logs for chunk ${ch}: ${providerSpecifics.getLoggingUrlForRendererFunction({
+                    functionName,
+                    region,
+                    rendererFunctionName: null,
+                    renderId: renderMetadata.renderId,
+                    chunk: ch,
+                })}`,
+            ].join('\n');
+        })
+            .slice(0, 5),
+    ].join('\n');
+};
+const makeTimeoutMessage = ({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, providerSpecifics, }) => {
+    const cloudWatchRendererUrl = providerSpecifics.getLoggingUrlForRendererFunction({
+        renderId,
+        functionName,
+        region,
+        rendererFunctionName: functionName,
+        chunk: null,
+    });
+    const cloudWatchLaunchUrl = providerSpecifics.getLoggingUrlForMethod({
+        renderId,
+        functionName,
+        method: constants_1.ServerlessRoutines.launch,
+        region,
+        rendererFunctionName: functionName,
+    });
+    const message = [
+        `The main function timed out after ${timeoutInMilliseconds}ms.`,
+        makeChunkMissingMessage({
+            missingChunks,
+            renderMetadata,
+            region,
+            providerSpecifics,
+            functionName,
+        }),
+        '',
+        `Consider increasing the timeout of your function.`,
+        `▸ You can use the "--timeout" parameter when deploying a function via CLI, or the "timeoutInSeconds" parameter when using the deployFunction() API.`,
+        `${docs_url_1.DOCS_URL}/docs/lambda/cli/functions#deploy`,
+        '',
+        '▸ Visit the logs for the main function:',
+        cloudWatchLaunchUrl,
+        '▸ Visit the logs for the renderer functions:',
+        cloudWatchRendererUrl,
+        '',
+        '▸ Get help on debugging this error:',
+        `${docs_url_1.DOCS_URL}/docs/lambda/troubleshooting/debug`,
+    ].join('\n');
+    return message;
+};
+exports.makeTimeoutMessage = makeTimeoutMessage;

package/dist/min-max.d.ts

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

package/dist/min-max.js

@@ -0,0 +1,33 @@
+"use strict";
+// Standard library Math.min and Math.max can throw
+// if array length is very long. Fixing this with own implementation
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.max = exports.min = void 0;
+const min = (arr) => {
+    if (arr.length === 0) {
+        throw new Error('Array of 0 length');
+    }
+    let smallest = arr[0];
+    for (let i = 0; i < arr.length; i++) {
+        const elem = arr[i];
+        if (elem < smallest) {
+            smallest = elem;
+        }
+    }
+    return smallest;
+};
+exports.min = min;
+const max = (arr) => {
+    if (arr.length === 0) {
+        throw new Error('Array of 0 length');
+    }
+    let biggest = arr[0];
+    for (let i = 0; i < arr.length; i++) {
+        const elem = arr[i];
+        if (elem > biggest) {
+            biggest = elem;
+        }
+    }
+    return biggest;
+};
+exports.max = max;

package/dist/most-expensive-chunks.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedTiming } from './types';
+export declare const OVERHEAD_TIME_PER_LAMBDA = 100;
+export type ExpensiveChunk = {
+    chunk: number;
+    frameRange: [number, number];
+    timeInMilliseconds: number;
+};
+export declare const getMostExpensiveChunks: ({ parsedTimings, framesPerFunction: framesPerLambda, firstFrame, lastFrame, }: {
+    parsedTimings: ParsedTiming[];
+    framesPerFunction: number;
+    firstFrame: number;
+    lastFrame: number;
+}) => ExpensiveChunk[];

package/dist/most-expensive-chunks.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMostExpensiveChunks = exports.OVERHEAD_TIME_PER_LAMBDA = void 0;
+exports.OVERHEAD_TIME_PER_LAMBDA = 100;
+const getMostExpensiveChunks = ({ parsedTimings, framesPerFunction: framesPerLambda, firstFrame, lastFrame, }) => {
+    const mostExpensiveChunks = parsedTimings
+        .slice(0)
+        .sort((a, b) => {
+        const durA = a.rendered - a.start;
+        const durB = b.rendered - b.start;
+        return durB - durA;
+    })
+        .slice(0, 5);
+    return mostExpensiveChunks.map((c) => {
+        const isLastChunk = c.chunk === parsedTimings.length - 1;
+        return {
+            timeInMilliseconds: c.rendered - c.start,
+            chunk: c.chunk,
+            frameRange: [
+                framesPerLambda * c.chunk + firstFrame,
+                isLastChunk
+                    ? lastFrame
+                    : framesPerLambda * (c.chunk + 1) - 1 + firstFrame,
+            ],
+        };
+    });
+};
+exports.getMostExpensiveChunks = getMostExpensiveChunks;

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

@@ -0,0 +1,24 @@
+import type { PostRenderData } from './constants';
+import type { RenderMetadata } from './render-metadata';
+import type { ChunkRetry, CloudProvider, ParsedTiming, ReceivedArtifact } from './types';
+import type { FunctionErrorInfo } from './write-error-to-storage';
+export type OverallRenderProgress<Provider extends CloudProvider> = {
+    chunks: number[];
+    framesRendered: number;
+    framesEncoded: number;
+    combinedFrames: number;
+    timeToCombine: number | null;
+    timeToEncode: number | null;
+    timeToRenderFrames: number | null;
+    lambdasInvoked: number;
+    retries: ChunkRetry[];
+    postRenderData: PostRenderData<Provider> | null;
+    timings: ParsedTiming[];
+    renderMetadata: RenderMetadata<Provider> | null;
+    errors: FunctionErrorInfo[];
+    timeoutTimestamp: number;
+    functionLaunched: number;
+    serveUrlOpened: number | null;
+    compositionValidated: number | null;
+    receivedArtifact: ReceivedArtifact<Provider>[];
+};

package/dist/overall-render-progress.js

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

package/dist/progress.d.ts

@@ -0,0 +1,16 @@
+import type { CustomCredentials } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { GenericRenderProgress } from './render-progress';
+import type { CloudProvider } from './types';
+export declare const getProgress: <Provider extends CloudProvider>({ bucketName, renderId, expectedBucketOwner, region, memorySizeInMb, timeoutInMilliseconds, customCredentials, providerSpecifics, forcePathStyle, functionName, }: {
+    bucketName: string;
+    renderId: string;
+    expectedBucketOwner: string | null;
+    region: Provider["region"];
+    memorySizeInMb: number;
+    timeoutInMilliseconds: number;
+    customCredentials: CustomCredentials<Provider> | null;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+    functionName: string;
+}) => Promise<GenericRenderProgress<Provider>>;

package/dist/progress.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProgress = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+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, _v, _w;
+    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)({
+            renderMetadata: overallProgress.renderMetadata,
+            bucketName,
+            customCredentials,
+            bucketNamePrefix: providerSpecifics.getBucketPrefix(),
+        });
+        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.estimatePriceFromMetadata)({
+        renderMetadata,
+        memorySizeInMb: (_j = (_h = providerSpecifics.parseFunctionName(renderMetadata.rendererFunctionName)) === null || _h === void 0 ? void 0 : _h.memorySizeInMb) !== null && _j !== void 0 ? _j : memorySizeInMb,
+        functionsInvoked: (_k = renderMetadata.estimatedRenderLambdaInvokations) !== null && _k !== void 0 ? _k : 0,
+        diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+        timings: (_l = overallProgress.timings) !== null && _l !== void 0 ? _l : [],
+        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 = ((_m = overallProgress.chunks) !== null && _m !== void 0 ? _m : []).length / chunkMultiplier ===
+        ((_o = renderMetadata.totalChunks) !== null && _o !== void 0 ? _o : 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(truthy_1.truthy);
+    return {
+        framesRendered: (_p = overallProgress.framesRendered) !== null && _p !== void 0 ? _p : 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: (_q = overallProgress.lambdasInvoked) !== null && _q !== void 0 ? _q : 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
+                ? ((_r = overallProgress.framesEncoded) !== null && _r !== void 0 ? _r : 0) / frameCount
+                : 0,
+            invoking: ((_s = overallProgress.lambdasInvoked) !== null && _s !== void 0 ? _s : 0) /
+                renderMetadata.estimatedRenderLambdaInvokations,
+            frames: ((_t = overallProgress.framesRendered) !== null && _t !== void 0 ? _t : 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: (_u = overallProgress.retries) !== null && _u !== void 0 ? _u : [],
+        outKey: null,
+        outBucket: null,
+        mostExpensiveFrameRanges: null,
+        timeToEncode: overallProgress.timeToEncode,
+        outputSizeInBytes: null,
+        estimatedBillingDurationInMilliseconds: priceFromBucket
+            ? priceFromBucket.estimatedBillingDurationInMilliseconds
+            : null,
+        combinedFrames: (_v = overallProgress.combinedFrames) !== null && _v !== void 0 ? _v : 0,
+        timeToCombine: (_w = overallProgress.timeToCombine) !== null && _w !== void 0 ? _w : null,
+        timeoutTimestamp: overallProgress.timeoutTimestamp,
+        type: 'success',
+        compositionValidated: overallProgress.compositionValidated,
+        functionLaunched: overallProgress.functionLaunched,
+        serveUrlOpened: overallProgress.serveUrlOpened,
+        artifacts: overallProgress.receivedArtifact,
+    };
+};
+exports.getProgress = getProgress;

package/dist/provider-implementation.d.ts

@@ -0,0 +1,193 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { Readable } from 'node:stream';
+import type { CustomCredentials, DownloadBehavior, Privacy, ServerlessRoutines } from './constants';
+import type { RenderMetadata } from './render-metadata';
+import type { ServerlessReturnValues } from './return-values';
+import type { OnMessage } from './streaming/streaming';
+import type { CallFunctionOptions, CloudProvider } from './types';
+export type ParseFunctionName = (functionName: string) => {
+    version: string;
+    memorySizeInMb: number;
+    diskSizeInMb: number;
+    timeoutInSeconds: number;
+} | null;
+type DeleteFile<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    key: string;
+    region: Provider['region'];
+    customCredentials: CustomCredentials<Provider> | null;
+    forcePathStyle: boolean;
+}) => Promise<void>;
+export type BucketWithLocation<Provider extends CloudProvider> = {
+    name: string;
+    creationDate: number;
+    region: Provider['region'];
+};
+type BucketExists<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    region: Provider['region'];
+    expectedBucketOwner: string | null;
+    forcePathStyle: boolean;
+}) => Promise<boolean>;
+type ReadFile<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    key: string;
+    region: Provider['region'];
+    expectedBucketOwner: string | null;
+    forcePathStyle: boolean;
+}) => Promise<Readable>;
+type GetBuckets<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+    forceBucketName: string | null;
+    forcePathStyle: boolean;
+}) => Promise<BucketWithLocation<Provider>[]>;
+type CreateBucket<Provider extends CloudProvider> = (params: {
+    region: Provider['region'];
+    bucketName: string;
+    forcePathStyle: boolean;
+    skipPutAcl: boolean;
+}) => Promise<void>;
+type ApplyLifeCycle<Provider extends CloudProvider> = (params: {
+    enableFolderExpiry: boolean | null;
+    bucketName: string;
+    region: Provider['region'];
+    customCredentials: CustomCredentials<Provider> | null;
+    forcePathStyle: boolean;
+}) => Promise<void>;
+type ListObjects<Provider extends CloudProvider> = (params: {
+    bucketName: string;
+    prefix: string;
+    region: Provider['region'];
+    expectedBucketOwner: string | null;
+    forcePathStyle: boolean;
+    continuationToken?: string;
+}) => Promise<BucketObject[]>;
+type BucketObject = {
+    Key: string;
+    LastModified: Date;
+    ETag: string;
+    Size: number;
+};
+type HeadFile<Provider extends CloudProvider> = (params: HeadFileInput<Provider>) => Promise<HeadFileOutput>;
+type RandomHash = () => string;
+type ConvertToServeUrl<Provider extends CloudProvider> = (params: {
+    urlOrId: string;
+    region: Provider['region'];
+    bucketName: string;
+}) => string;
+type HeadFileOutput = {
+    LastModified?: Date | undefined;
+    ContentLength?: number | undefined;
+};
+export type DeleteFunctionInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    functionName: string;
+};
+export type DeleteFunction<Provider extends CloudProvider> = (options: DeleteFunctionInput<Provider>) => Promise<void>;
+export type WriteFileInput<Provider extends CloudProvider> = {
+    bucketName: string;
+    key: string;
+    body: Readable | string | Uint8Array;
+    region: Provider['region'];
+    privacy: Privacy;
+    expectedBucketOwner: string | null;
+    downloadBehavior: DownloadBehavior | null;
+    customCredentials: CustomCredentials<Provider> | null;
+    forcePathStyle: boolean;
+};
+type WriteFile<Provider extends CloudProvider> = (params: WriteFileInput<Provider>) => Promise<void>;
+type HeadFileInput<Provider extends CloudProvider> = {
+    bucketName: string;
+    key: string;
+    region: Provider['region'];
+    customCredentials: CustomCredentials<Provider> | null;
+    forcePathStyle: boolean;
+};
+export type CallFunctionAsync<Provider extends CloudProvider> = <T extends ServerlessRoutines>({ functionName, payload, region, timeoutInTest, }: CallFunctionOptions<T, Provider>) => Promise<void>;
+export type CallFunctionStreaming<Provider extends CloudProvider> = <T extends ServerlessRoutines>(options: CallFunctionOptions<T, Provider> & {
+    receivedStreamingPayload: OnMessage<Provider>;
+    retriesRemaining: number;
+}) => Promise<void>;
+export type CallFunctionSync<Provider extends CloudProvider> = <T extends ServerlessRoutines>({ functionName, payload, region, timeoutInTest, }: CallFunctionOptions<T, Provider>) => Promise<ServerlessReturnValues<Provider>[T]>;
+export type GetOutputUrl<Provider extends CloudProvider> = (options: {
+    renderMetadata: RenderMetadata<Provider>;
+    bucketName: string;
+    customCredentials: CustomCredentials<Provider> | null;
+    currentRegion: Provider['region'];
+}) => {
+    url: string;
+    key: string;
+};
+export type EstimatePriceInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    memorySizeInMb: number;
+    diskSizeInMb: number;
+    lambdasInvoked: number;
+    durationInMilliseconds: number;
+};
+export type EstimatePrice<Provider extends CloudProvider> = ({ region, memorySizeInMb, diskSizeInMb, lambdasInvoked, ...other }: EstimatePriceInput<Provider>) => number;
+export type GetLoggingUrlForRendererFunction<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+    functionName: string;
+    rendererFunctionName: string | null;
+    renderId: string;
+    chunk: null | number;
+}) => string;
+export type GetFunctionsInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    compatibleOnly: boolean;
+    logLevel?: LogLevel;
+};
+export type GetLoggingUrlForMethod<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+    functionName: string;
+    method: ServerlessRoutines;
+    rendererFunctionName: string | null;
+    renderId: string;
+}) => string;
+export type GetAccountId<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+}) => Promise<string>;
+export type FunctionInfo = {
+    functionName: string;
+    timeoutInSeconds: number;
+    memorySizeInMb: number;
+    version: string | null;
+    diskSizeInMb: number;
+};
+export type GetFunctions<Provider extends CloudProvider> = (params: GetFunctionsInput<Provider>) => Promise<FunctionInfo[]>;
+export type ProviderSpecifics<Provider extends CloudProvider> = {
+    getChromiumPath: () => string | null;
+    getBuckets: GetBuckets<Provider>;
+    getBucketPrefix: () => string;
+    createBucket: CreateBucket<Provider>;
+    applyLifeCycle: ApplyLifeCycle<Provider>;
+    listObjects: ListObjects<Provider>;
+    deleteFile: DeleteFile<Provider>;
+    bucketExists: BucketExists<Provider>;
+    randomHash: RandomHash;
+    readFile: ReadFile<Provider>;
+    writeFile: WriteFile<Provider>;
+    headFile: HeadFile<Provider>;
+    convertToServeUrl: ConvertToServeUrl<Provider>;
+    printLoggingHelper: boolean;
+    validateDeleteAfter: (lifeCycleValue: unknown) => void;
+    callFunctionAsync: CallFunctionAsync<Provider>;
+    callFunctionStreaming: CallFunctionStreaming<Provider>;
+    callFunctionSync: CallFunctionSync<Provider>;
+    estimatePrice: EstimatePrice<Provider>;
+    getLoggingUrlForRendererFunction: GetLoggingUrlForRendererFunction<Provider>;
+    getLoggingUrlForMethod: GetLoggingUrlForMethod<Provider>;
+    getEphemeralStorageForPriceCalculation: () => number;
+    getOutputUrl: GetOutputUrl<Provider>;
+    isFlakyError: (err: Error) => boolean;
+    serverStorageProductName: () => string;
+    getMaxStillInlinePayloadSize: () => number;
+    getMaxNonInlinePayloadSizePerFunction: () => number;
+    getAccountId: GetAccountId<Provider>;
+    deleteFunction: DeleteFunction<Provider>;
+    getFunctions: GetFunctions<Provider>;
+    parseFunctionName: ParseFunctionName;
+    checkCredentials: () => void;
+};
+export {};

package/dist/provider-implementation.js

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