@remotion/serverless 4.0.244 → 4.0.246

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.estimatePriceFromMetadata)({
+        renderMetadata,
+        memorySizeInMb,
+        functionsInvoked: (_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/provider-implementation.d.ts

@@ -1,8 +1,13 @@
-import type { EmittedArtifact } from '@remotion/renderer';
+import type { bundle } from '@remotion/bundler';
+import type { ChromiumOptions, EmittedArtifact, LogLevel } from '@remotion/renderer';
 import type { Readable } from 'stream';
-import type { CustomCredentials, DownloadBehavior, Privacy } from './constants';
+import type { CustomCredentials, DeleteAfter, DownloadBehavior, Privacy, ServerlessRoutines } from './constants';
+import type { LaunchedBrowser } from './get-browser-instance';
 import type { GetFolderFiles } from './get-files-in-folder';
-import type { CloudProvider, ReceivedArtifact } from './still';
+import type { RenderMetadata } from './render-metadata';
+import type { ServerlessReturnValues } from './return-values';
+import type { OnMessage } from './streaming/streaming';
+import type { CallFunctionOptions, CloudProvider, ReceivedArtifact } from './types';
 export type BucketWithLocation<Provider extends CloudProvider> = {
     name: string;
     creationDate: number;
@@ -96,6 +101,134 @@ export type MakeArtifactWithDetails<Provider extends CloudProvider> = (params: {
     storageKey: string;
     artifact: EmittedArtifact;
 }) => ReceivedArtifact<Provider>;
+export type DebuggingTimer = (label: string, logLevel: LogLevel) => {
+    end: () => void;
+};
+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 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 GetLoggingUrlForMethod<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+    functionName: string;
+    method: ServerlessRoutines;
+    rendererFunctionName: string | null;
+    renderId: string;
+}) => string;
+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 GetBrowserInstance = <Provider extends CloudProvider>({ logLevel, indent, chromiumOptions, providerSpecifics, insideFunctionSpecifics, }: {
+    logLevel: LogLevel;
+    indent: boolean;
+    chromiumOptions: ChromiumOptions;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+}) => Promise<LaunchedBrowser>;
+export type ForgetBrowserEventLoop = (logLevel: LogLevel) => void;
+export type GenerateRenderId = (options: {
+    deleteAfter: DeleteAfter | null;
+    randomHashFn: () => string;
+}) => string;
+export type GetAccountId<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+}) => Promise<string>;
+export type DeleteFunctionInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    functionName: string;
+};
+export type DeleteFunction<Provider extends CloudProvider> = (options: DeleteFunctionInput<Provider>) => Promise<void>;
+export type GetFunctionsInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    compatibleOnly: boolean;
+    logLevel?: LogLevel;
+};
+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 ReadDir = ({ dir, etags, originalDir, onProgress, }: {
+    dir: string;
+    etags: {
+        [key: string]: () => Promise<string>;
+    };
+    originalDir: string;
+    onProgress: (bytes: number) => void;
+}) => {
+    [key: string]: () => Promise<string>;
+};
+export type UploadDirProgress = {
+    totalFiles: number;
+    filesUploaded: number;
+    totalSize: number;
+    sizeUploaded: number;
+};
+export type UploadDir<Provider extends CloudProvider> = (options: {
+    bucket: string;
+    region: Provider['region'];
+    localDir: string;
+    keyPrefix: string;
+    onProgress: (progress: UploadDirProgress) => void;
+    privacy: Privacy;
+    toUpload: string[];
+    forcePathStyle: boolean;
+}) => Promise<void>;
+type CreateFunctionOptions<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    logLevel: LogLevel;
+    ephemerealStorageInMb: number;
+    timeoutInSeconds: number;
+    memorySizeInMb: number;
+    functionName: string;
+    zipFile: string;
+} & Provider['creationFunctionOptions'];
+export type CreateFunction<Provider extends CloudProvider> = (options: CreateFunctionOptions<Provider>) => Promise<{
+    FunctionName: string;
+}>;
+export type InsideFunctionSpecifics = {
+    getBrowserInstance: GetBrowserInstance;
+    forgetBrowserEventLoop: ForgetBrowserEventLoop;
+    timer: DebuggingTimer;
+    generateRandomId: GenerateRenderId;
+    deleteTmpDir: () => Promise<void>;
+    getCurrentFunctionName: () => string;
+    getCurrentMemorySizeInMb: () => number;
+};
+export type FullClientSpecifics<Provider extends CloudProvider> = {
+    id: '__remotion_full_client_specifics';
+    bundleSite: typeof bundle;
+    readDirectory: ReadDir;
+    uploadDir: UploadDir<Provider>;
+    createFunction: CreateFunction<Provider>;
+    checkCredentials: () => void;
+};
 export type ProviderSpecifics<Provider extends CloudProvider> = {
     getChromiumPath: () => string | null;
     getCurrentRegionInFunction: () => Provider['region'];
@@ -113,5 +246,21 @@ export type ProviderSpecifics<Provider extends CloudProvider> = {
     printLoggingHelper: boolean;
     getFolderFiles: GetFolderFiles;
     makeArtifactWithDetails: MakeArtifactWithDetails<Provider>;
+    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>;
 };
 export {};

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-metadata.d.ts

@@ -1,6 +1,6 @@
 import type { AudioCodec, DeleteAfter, StillImageFormat, VideoImageFormat } from '@remotion/renderer';
 import type { DownloadBehavior, OutNameInputWithoutCredentials, Privacy, SerializedInputProps, ServerlessCodec } from './constants';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 type Discriminated = {
     type: 'still';
     imageFormat: StillImageFormat;

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-error-to-storage';
+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/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>;