@remotion/serverless 4.0.244 → 4.0.245

package/.turbo/turbo-formatting.log

@@ -0,0 +1,7 @@
+
+
+> @remotion/serverless@4.0.244 formatting /Users/jonathanburger/remotion/packages/serverless
+> prettier src --check
+
+Checking formatting...
+src/await.tssrc/client.tssrc/compositions.tssrc/compress-props.tssrc/constants.tssrc/error-category.tssrc/expected-out-name.tssrc/get-browser-instance.tssrc/get-custom-out-name.tssrc/get-files-in-folder.tssrc/get-or-create-bucket.tssrc/index.tssrc/info.tssrc/input-props-keys.tssrc/make-bucket-name.tssrc/provider-implementation.tssrc/render-metadata.tssrc/serialize-artifact.tssrc/still.tssrc/stream-to-string.tssrc/streaming/response-stream.tssrc/streaming/stream-writer.tssrc/streaming/streaming.tssrc/test/expected-out-name.test.tssrc/truthy.tssrc/validate-bucket-name.tssrc/validate-composition.tssrc/validate-outname.tssrc/validate-webhook.tssrc/write-lambda-error.tsAll matched files use Prettier code style!

package/.turbo/turbo-lint.log

@@ -0,0 +1,11 @@
+
+
+> @remotion/serverless@4.0.244 lint /Users/jonathanburger/remotion/packages/serverless
+> eslint src
+
+
+/Users/jonathanburger/remotion/packages/serverless/src/streaming/response-stream.ts
+  19:10  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
+
+✖ 1 problem (0 errors, 1 warning)
+

package/.turbo/turbo-make.log

@@ -1,5 +1,5 @@
 
 
-> @remotion/serverless@4.0.243 make /Users/jonathanburger/remotion/packages/serverless
+> @remotion/serverless@4.0.244 make /Users/jonathanburger/remotion/packages/serverless
 > tsc -d
 

package/LICENSE.md

@@ -11,7 +11,7 @@ Depending on the type of your legal entity, you are granted permission to use Re
 
 ## Free license
 
-Copyright © 2024 [Remotion](https://www.remotion.dev)
+Copyright © 2025 [Remotion](https://www.remotion.dev)
 
 ### Eligibility
 

package/dist/best-frames-per-function-param.d.ts

@@ -0,0 +1 @@
+export declare const bestFramesPerFunctionParam: (frameCount: number) => number;

package/dist/best-frames-per-function-param.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bestFramesPerFunctionParam = void 0;
+const no_react_1 = require("remotion/no-react");
+// Always update the code in docs/lambda/concurrency.md too
+const bestFramesPerFunctionParam = (frameCount) => {
+    // Between 0 and 10 minutes (at 30fps), interpolate the concurrency from 75 to 150
+    const concurrency = (0, no_react_1.interpolate)(frameCount, [0, 18000], [75, 150], {
+        extrapolateRight: 'clamp',
+    });
+    // At least have 20 as a `framesPerLambda` value
+    const framesPerLambda = Math.max(frameCount / concurrency, 20);
+    // Evenly distribute: For 21 frames over 2 lambda functions, distribute as 11 + 10 ==> framesPerLambda = 11
+    const lambdasNeeded = Math.ceil(frameCount / framesPerLambda);
+    return Math.ceil(frameCount / lambdasNeeded);
+};
+exports.bestFramesPerFunctionParam = bestFramesPerFunctionParam;

package/dist/calculate-chunk-times.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedTiming } from './types';
+export declare const calculateChunkTimes: ({ type, timings, }: {
+    type: "combined-time-for-cost-calculation" | "absolute-time";
+    timings: ParsedTiming[];
+}) => number;

package/dist/calculate-chunk-times.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateChunkTimes = void 0;
+const min_max_1 = require("./min-max");
+const getAbsoluteTime = (parsedTimings) => {
+    if (parsedTimings.length === 0) {
+        return 0;
+    }
+    const allEnds = parsedTimings.map((p) => p.rendered);
+    const allStarts = parsedTimings.map((p) => p.start);
+    const biggestEnd = (0, min_max_1.max)(allEnds);
+    const smallestStart = (0, min_max_1.min)(allStarts);
+    return Math.max(0, biggestEnd - smallestStart);
+};
+const calculateChunkTimes = ({ type, timings, }) => {
+    const parsedTimings = timings;
+    const absoluteTime = getAbsoluteTime(parsedTimings);
+    if (type === 'combined-time-for-cost-calculation') {
+        const totalEncodingTimings = parsedTimings
+            .map((p) => Math.max(0, p.rendered - p.start))
+            .reduce((a, b) => a + b, 0);
+        return totalEncodingTimings + absoluteTime;
+    }
+    if (type === 'absolute-time') {
+        return absoluteTime;
+    }
+    throw new Error('invalid time for calculate chunk times');
+};
+exports.calculateChunkTimes = calculateChunkTimes;

package/dist/can-concat-seamlessly.d.ts

@@ -0,0 +1,3 @@
+import type { AudioCodec, Codec } from '@remotion/renderer';
+export declare const canConcatAudioSeamlessly: (audioCodec: AudioCodec | null, chunkDurationInFrames: number) => boolean;
+export declare const canConcatVideoSeamlessly: (codec: Codec) => codec is "h264";

package/dist/can-concat-seamlessly.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canConcatVideoSeamlessly = exports.canConcatAudioSeamlessly = void 0;
+// Cannot do WAV yet, because currently assumes AAC in+outpoint
+const canConcatAudioSeamlessly = (audioCodec, chunkDurationInFrames) => {
+    // Rendering a chunk that is too small generates too much overhead
+    // and is currently buggy
+    if (chunkDurationInFrames <= 4) {
+        return false;
+    }
+    return audioCodec === 'aac';
+};
+exports.canConcatAudioSeamlessly = canConcatAudioSeamlessly;
+const canConcatVideoSeamlessly = (codec) => {
+    return codec === 'h264';
+};
+exports.canConcatVideoSeamlessly = canConcatVideoSeamlessly;

package/dist/cleanup-props.d.ts

@@ -0,0 +1,9 @@
+import type { SerializedInputProps } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './types';
+export declare const cleanupProps: <Provider extends CloudProvider>({ serializedResolvedProps, inputProps, providerSpecifics, forcePathStyle, }: {
+    serializedResolvedProps: SerializedInputProps;
+    inputProps: SerializedInputProps;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<[number, number]>;

package/dist/cleanup-props.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupProps = void 0;
+const cleanup_serialized_input_props_1 = require("./cleanup-serialized-input-props");
+const cleanupProps = ({ serializedResolvedProps, inputProps, providerSpecifics, forcePathStyle, }) => {
+    const cleanupSerializedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedInputProps)({
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        serialized: inputProps,
+        providerSpecifics,
+        forcePathStyle,
+    });
+    const cleanupResolvedInputPropsProm = (0, cleanup_serialized_input_props_1.cleanupSerializedResolvedProps)({
+        region: providerSpecifics.getCurrentRegionInFunction(),
+        serialized: serializedResolvedProps,
+        providerSpecifics,
+        forcePathStyle,
+    });
+    return Promise.all([
+        cleanupSerializedInputPropsProm,
+        cleanupResolvedInputPropsProm,
+    ]);
+};
+exports.cleanupProps = cleanupProps;

package/dist/cleanup-serialized-input-props.d.ts

@@ -0,0 +1,15 @@
+import type { SerializedInputProps } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './types';
+export declare const cleanupSerializedInputProps: <Provider extends CloudProvider>({ serialized, region, providerSpecifics, forcePathStyle, }: {
+    serialized: SerializedInputProps;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<number>;
+export declare const cleanupSerializedResolvedProps: <Provider extends CloudProvider>({ serialized, region, providerSpecifics, forcePathStyle, }: {
+    serialized: SerializedInputProps;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<number>;

package/dist/cleanup-serialized-input-props.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupSerializedResolvedProps = exports.cleanupSerializedInputProps = void 0;
+const input_props_keys_1 = require("./input-props-keys");
+const cleanupSerializedInputProps = async ({ serialized, region, providerSpecifics, forcePathStyle, }) => {
+    if (serialized.type === 'payload') {
+        return 0;
+    }
+    const time = Date.now();
+    await providerSpecifics.deleteFile({
+        bucketName: serialized.bucketName,
+        key: (0, input_props_keys_1.inputPropsKey)(serialized.hash),
+        region,
+        customCredentials: null,
+        forcePathStyle,
+    });
+    return Date.now() - time;
+};
+exports.cleanupSerializedInputProps = cleanupSerializedInputProps;
+const cleanupSerializedResolvedProps = async ({ serialized, region, providerSpecifics, forcePathStyle, }) => {
+    if (serialized.type === 'payload') {
+        return 0;
+    }
+    const time = Date.now();
+    await providerSpecifics.deleteFile({
+        bucketName: serialized.bucketName,
+        key: (0, input_props_keys_1.resolvedPropsKey)(serialized.hash),
+        region,
+        customCredentials: null,
+        forcePathStyle,
+    });
+    return Date.now() - time;
+};
+exports.cleanupSerializedResolvedProps = cleanupSerializedResolvedProps;

package/dist/concat-videos.d.ts

@@ -0,0 +1,26 @@
+import type { AudioCodec, CancelSignal, LogLevel } from '@remotion/renderer';
+import { type ServerlessCodec } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './types';
+export declare const concatVideos: <Provider extends CloudProvider>({ onProgress, numberOfFrames, codec, fps, numberOfGifLoops, files, outdir, audioCodec, audioBitrate, logLevel, framesPerLambda, binariesDirectory, cancelSignal, preferLossless, muted, metadata, providerSpecifics, }: {
+    onProgress: (frames: number) => void;
+    numberOfFrames: number;
+    codec: ServerlessCodec;
+    fps: number;
+    numberOfGifLoops: number | null;
+    files: string[];
+    outdir: string;
+    audioCodec: AudioCodec | null;
+    audioBitrate: string | null;
+    logLevel: LogLevel;
+    framesPerLambda: number;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    preferLossless: boolean;
+    muted: boolean;
+    metadata: Record<string, string> | null;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => Promise<{
+    outfile: string;
+    cleanupChunksProm: Promise<void>;
+}>;

package/dist/concat-videos.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatVideos = void 0;
+const renderer_1 = require("@remotion/renderer");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = require("node:path");
+const can_concat_seamlessly_1 = require("./can-concat-seamlessly");
+const constants_1 = require("./constants");
+const concatVideos = async ({ onProgress, numberOfFrames, codec, fps, numberOfGifLoops, files, outdir, audioCodec, audioBitrate, logLevel, framesPerLambda, binariesDirectory, cancelSignal, preferLossless, muted, metadata, providerSpecifics, }) => {
+    const outfile = (0, node_path_1.join)(renderer_1.RenderInternals.tmpDir(constants_1.REMOTION_CONCATED_TOKEN), `concat.${renderer_1.RenderInternals.getFileExtensionFromCodec(codec, audioCodec)}`);
+    const combine = providerSpecifics.timer('Combine chunks', logLevel);
+    const filelistDir = renderer_1.RenderInternals.tmpDir(constants_1.REMOTION_FILELIST_TOKEN);
+    const chunkDurationInSeconds = framesPerLambda / fps;
+    const resolvedAudioCodec = renderer_1.RenderInternals.resolveAudioCodec({
+        setting: audioCodec,
+        codec,
+        preferLossless,
+        separateAudioTo: null,
+    });
+    const seamlessAudio = (0, can_concat_seamlessly_1.canConcatAudioSeamlessly)(resolvedAudioCodec, framesPerLambda);
+    const seamlessVideo = (0, can_concat_seamlessly_1.canConcatVideoSeamlessly)(codec);
+    await renderer_1.RenderInternals.combineChunks({
+        files,
+        filelistDir,
+        output: outfile,
+        onProgress,
+        numberOfFrames,
+        codec,
+        fps,
+        numberOfGifLoops,
+        resolvedAudioCodec,
+        audioBitrate,
+        indent: false,
+        logLevel,
+        chunkDurationInSeconds,
+        binariesDirectory,
+        cancelSignal,
+        seamlessAudio,
+        seamlessVideo,
+        muted,
+        metadata,
+    });
+    combine.end();
+    const cleanupChunksProm = node_fs_1.default.promises.rm(outdir, {
+        recursive: true,
+        force: true,
+    });
+    return { outfile, cleanupChunksProm };
+};
+exports.concatVideos = concatVideos;

package/dist/create-post-render-data.d.ts

@@ -0,0 +1,20 @@
+import type { PostRenderData } from './constants';
+import type { OutputFileMetadata } from './find-output-file-in-bucket';
+import type { OverallRenderProgress } from './overall-render-progress';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+import type { EnhancedErrorInfo } from './write-lambda-error';
+export declare const createPostRenderData: <Provider extends CloudProvider>({ region, memorySizeInMb, renderMetadata, errorExplanations, timeToDelete, outputFile, timeToCombine, overallProgress, timeToFinish, outputSize, providerSpecifics, }: {
+    region: Provider["region"];
+    memorySizeInMb: number;
+    renderMetadata: RenderMetadata<Provider>;
+    timeToDelete: number;
+    errorExplanations: EnhancedErrorInfo[];
+    outputFile: OutputFileMetadata;
+    timeToCombine: number | null;
+    overallProgress: OverallRenderProgress<Provider>;
+    timeToFinish: number;
+    outputSize: number;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => PostRenderData<Provider>;

package/dist/create-post-render-data.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostRenderData = void 0;
+const calculate_chunk_times_1 = require("./calculate-chunk-times");
+const most_expensive_chunks_1 = require("./most-expensive-chunks");
+const createPostRenderData = ({ region, memorySizeInMb, renderMetadata, errorExplanations, timeToDelete, outputFile, timeToCombine, overallProgress, timeToFinish, outputSize, providerSpecifics, }) => {
+    const parsedTimings = overallProgress.timings;
+    const estimatedBillingDurationInMilliseconds = parsedTimings
+        .map((p) => p.rendered - p.start + most_expensive_chunks_1.OVERHEAD_TIME_PER_LAMBDA)
+        .reduce((a, b) => a + b);
+    const cost = providerSpecifics.estimatePrice({
+        durationInMilliseconds: estimatedBillingDurationInMilliseconds,
+        memorySizeInMb,
+        region,
+        lambdasInvoked: renderMetadata.estimatedTotalLambdaInvokations,
+        diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
+    });
+    if (!outputFile) {
+        throw new Error('Cannot wrap up without an output file in the S3 bucket.');
+    }
+    const endTime = Date.now();
+    if (overallProgress.timeToEncode === null) {
+        throw new Error('Expected time to encode to be set');
+    }
+    if (overallProgress.timeToRenderFrames === null) {
+        throw new Error('Expected time to encode to be set');
+    }
+    return {
+        cost: {
+            currency: 'USD',
+            disclaimer: 'Estimated cost for lambda invocations only. Does not include cost for S3 storage and data transfer.',
+            estimatedCost: cost,
+            estimatedDisplayCost: `$${new Intl.NumberFormat('en-US', {
+                currency: 'USD',
+                currencyDisplay: 'narrowSymbol',
+            }).format(cost)}`,
+        },
+        outputFile: outputFile.url,
+        timeToFinish,
+        errors: errorExplanations,
+        startTime: renderMetadata.startedDate,
+        endTime,
+        outputSize,
+        renderSize: outputSize,
+        filesCleanedUp: 0,
+        timeToEncode: overallProgress.timeToEncode,
+        timeToCleanUp: timeToDelete,
+        timeToRenderChunks: (0, calculate_chunk_times_1.calculateChunkTimes)({
+            type: 'absolute-time',
+            timings: overallProgress.timings,
+        }),
+        timeToRenderFrames: overallProgress.timeToRenderFrames,
+        retriesInfo: overallProgress.retries,
+        mostExpensiveFrameRanges: renderMetadata.type === 'still'
+            ? []
+            : (0, most_expensive_chunks_1.getMostExpensiveChunks)({
+                parsedTimings,
+                framesPerLambda: renderMetadata.framesPerLambda,
+                firstFrame: renderMetadata.frameRange[0],
+                lastFrame: renderMetadata.frameRange[1],
+            }),
+        deleteAfter: renderMetadata.deleteAfter,
+        estimatedBillingDurationInMilliseconds,
+        timeToCombine: timeToCombine !== null && timeToCombine !== void 0 ? timeToCombine : null,
+        artifactProgress: overallProgress.receivedArtifact,
+    };
+};
+exports.createPostRenderData = createPostRenderData;

package/dist/docs-url.d.ts

@@ -0,0 +1 @@
+export declare const DOCS_URL = "https://remotion.dev";

package/dist/docs-url.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCS_URL = void 0;
+exports.DOCS_URL = 'https://remotion.dev';

package/dist/estimate-price-from-bucket.d.ts

@@ -0,0 +1,15 @@
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider, ParsedTiming } from './types';
+export declare const estimatePriceFromBucket: <Provider extends CloudProvider>({ renderMetadata, memorySizeInMb, diskSizeInMb, lambdasInvoked, timings, region, providerSpecifics, }: {
+    renderMetadata: RenderMetadata<Provider> | null;
+    memorySizeInMb: number;
+    diskSizeInMb: number;
+    lambdasInvoked: number;
+    timings: ParsedTiming[];
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => {
+    accruedSoFar: number;
+    estimatedBillingDurationInMilliseconds: number;
+} | null;

package/dist/estimate-price-from-bucket.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimatePriceFromBucket = void 0;
+const calculate_chunk_times_1 = require("./calculate-chunk-times");
+const estimatePriceFromBucket = ({ renderMetadata, memorySizeInMb, diskSizeInMb, lambdasInvoked, timings, region, providerSpecifics, }) => {
+    var _a, _b;
+    if (!renderMetadata) {
+        return null;
+    }
+    const elapsedTime = Math.max(0, Date.now() - ((_a = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.startedDate) !== null && _a !== void 0 ? _a : 0));
+    const unfinished = Math.max(0, ((_b = renderMetadata === null || renderMetadata === void 0 ? void 0 : renderMetadata.totalChunks) !== null && _b !== void 0 ? _b : 0) - timings.length);
+    const timeElapsedOfUnfinished = new Array(unfinished)
+        .fill(true)
+        .map(() => elapsedTime)
+        .reduce((a, b) => a + b, 0);
+    const estimatedBillingDurationInMilliseconds = (0, calculate_chunk_times_1.calculateChunkTimes)({
+        type: 'combined-time-for-cost-calculation',
+        timings,
+    }) + timeElapsedOfUnfinished;
+    const accruedSoFar = Number(providerSpecifics
+        .estimatePrice({
+        region,
+        durationInMilliseconds: estimatedBillingDurationInMilliseconds,
+        memorySizeInMb,
+        diskSizeInMb,
+        lambdasInvoked,
+    })
+        .toPrecision(5));
+    return { accruedSoFar, estimatedBillingDurationInMilliseconds };
+};
+exports.estimatePriceFromBucket = estimatePriceFromBucket;

package/dist/find-output-file-in-bucket.d.ts

@@ -0,0 +1,16 @@
+import type { CustomCredentials } from './constants';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+export type OutputFileMetadata = {
+    url: string;
+};
+export declare const findOutputFileInBucket: <Provider extends CloudProvider>({ region, renderMetadata, bucketName, customCredentials, currentRegion, providerSpecifics, forcePathStyle, }: {
+    region: Provider["region"];
+    renderMetadata: RenderMetadata<Provider>;
+    bucketName: string;
+    customCredentials: CustomCredentials<Provider> | null;
+    currentRegion: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<OutputFileMetadata | null>;

package/dist/find-output-file-in-bucket.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findOutputFileInBucket = void 0;
+const expected_out_name_1 = require("./expected-out-name");
+const findOutputFileInBucket = async ({ region, renderMetadata, bucketName, customCredentials, currentRegion, providerSpecifics, forcePathStyle, }) => {
+    if (!renderMetadata) {
+        throw new Error('unexpectedly did not get renderMetadata');
+    }
+    const { renderBucketName, key } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, bucketName, customCredentials);
+    try {
+        await providerSpecifics.headFile({
+            bucketName,
+            key,
+            region,
+            customCredentials,
+            forcePathStyle,
+        });
+        return {
+            url: providerSpecifics.getOutputUrl({
+                renderMetadata,
+                bucketName,
+                customCredentials,
+                currentRegion,
+            }).url,
+        };
+    }
+    catch (err) {
+        if (err.name === 'NotFound') {
+            return null;
+        }
+        if (err.message === 'UnknownError' ||
+            err.$metadata
+                .httpStatusCode === 403) {
+            throw new Error(`Unable to access item "${key}" from bucket "${renderBucketName}" ${(customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.endpoint)
+                ? `(S3 Endpoint = ${customCredentials === null || customCredentials === void 0 ? void 0 : customCredentials.endpoint})`
+                : ''}. The Lambda role must have permission for both "s3:GetObject" and "s3:ListBucket" actions.`);
+        }
+        throw err;
+    }
+};
+exports.findOutputFileInBucket = findOutputFileInBucket;

package/dist/format-costs-info.d.ts

@@ -0,0 +1,2 @@
+import type { CostsInfo } from './types';
+export declare const formatCostsInfo: (accrued: number) => CostsInfo;

package/dist/format-costs-info.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCostsInfo = void 0;
+const display = (accrued) => {
+    if (accrued < 0.001) {
+        return '<$0.001';
+    }
+    return new Intl.NumberFormat('en-US', {
+        currency: 'USD',
+        style: 'currency',
+        currencyDisplay: 'narrowSymbol',
+        minimumFractionDigits: 3,
+    }).format(accrued);
+};
+const formatCostsInfo = (accrued) => {
+    return {
+        accruedSoFar: accrued,
+        displayCost: display(accrued),
+        currency: 'USD',
+        disclaimer: 'Estimated cost only. Does not include charges for other AWS services.',
+    };
+};
+exports.formatCostsInfo = formatCostsInfo;

package/dist/get-overall-progress-from-storage.d.ts

@@ -0,0 +1,11 @@
+import type { OverallRenderProgress } from './overall-render-progress';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './types';
+export declare const getOverallProgressFromStorage: <Provider extends CloudProvider>({ renderId, bucketName, expectedBucketOwner, region, providerSpecifics, forcePathStyle, }: {
+    renderId: string;
+    expectedBucketOwner: string | null;
+    bucketName: string;
+    region: Provider["region"];
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<OverallRenderProgress<Provider>>;

package/dist/get-overall-progress-from-storage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOverallProgressFromStorage = void 0;
+const constants_1 = require("./constants");
+const stream_to_string_1 = require("./stream-to-string");
+const getOverallProgressFromStorage = async ({ renderId, bucketName, expectedBucketOwner, region, providerSpecifics, forcePathStyle, }) => {
+    try {
+        const Body = await providerSpecifics.readFile({
+            bucketName,
+            key: (0, constants_1.overallProgressKey)(renderId),
+            expectedBucketOwner,
+            region,
+            forcePathStyle,
+        });
+        const str = await (0, stream_to_string_1.streamToString)(Body);
+        return JSON.parse(str);
+    }
+    catch (err) {
+        if (err.name === 'NotFound') {
+            throw new TypeError(`No render with ID "${renderId}" found in bucket ${bucketName} and region ${region}`);
+        }
+        throw err;
+    }
+};
+exports.getOverallProgressFromStorage = getOverallProgressFromStorage;

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

@@ -0,0 +1,9 @@
+export declare const getOverallProgress: ({ encoding, invoking, frames, invokedLambda, visitedServeUrl, gotComposition, combining, }: {
+    invokedLambda: number;
+    visitedServeUrl: number | null;
+    gotComposition: number | null;
+    encoding: number;
+    invoking: number;
+    frames: number;
+    combining: number;
+}) => number;

package/dist/get-overall-progress.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOverallProgress = void 0;
+const weights = {
+    evaluating: 0.1,
+    encoding: 0.1,
+    frames: 0.6,
+    invoking: 0.1,
+    combining: 0.1,
+};
+const getOverallProgress = ({ encoding, invoking, frames, invokedLambda, visitedServeUrl, gotComposition, combining, }) => {
+    const evaluationProgress = [
+        Boolean(invokedLambda),
+        Boolean(visitedServeUrl),
+        Boolean(gotComposition),
+    ].reduce((a, b) => Number(a) + Number(b), 0) / 3;
+    return (evaluationProgress * weights.evaluating +
+        encoding * weights.encoding +
+        invoking * weights.invoking +
+        frames * weights.frames +
+        combining * weights.combining);
+};
+exports.getOverallProgress = getOverallProgress;

package/dist/handlers/compositions.d.ts

@@ -0,0 +1,11 @@
+import type { ServerlessPayload } from '../constants';
+import type { ProviderSpecifics } from '../provider-implementation';
+import type { CloudProvider } from '../types';
+type Options = {
+    expectedBucketOwner: string;
+};
+export declare const compositionsHandler: <Provider extends CloudProvider>(lambdaParams: ServerlessPayload<Provider>, options: Options, providerSpecifics: ProviderSpecifics<Provider>) => Promise<{
+    compositions: import("remotion").VideoConfig[];
+    type: "success";
+}>;
+export {};