@remotion/serverless 4.0.244 → 4.0.246

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimatePriceFromMetadata = void 0;
+const calculate_chunk_times_1 = require("./calculate-chunk-times");
+const estimatePriceFromMetadata = ({ renderMetadata, memorySizeInMb, diskSizeInMb, functionsInvoked, 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: functionsInvoked,
+    })
+        .toPrecision(5));
+    return { accruedSoFar, estimatedBillingDurationInMilliseconds };
+};
+exports.estimatePriceFromMetadata = estimatePriceFromMetadata;

package/dist/expected-out-name.d.ts

@@ -1,5 +1,5 @@
 import { type CustomCredentials, type OutNameInput, type OutNameOutput } from './constants';
 import type { RenderMetadata } from './render-metadata';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 export declare const getCredentialsFromOutName: <Provider extends CloudProvider>(name: OutNameInput<Provider> | null) => CustomCredentials<Provider> | null;
 export declare const getExpectedOutName: <Provider extends CloudProvider>(renderMetadata: RenderMetadata<Provider>, bucketName: string, customCredentials: CustomCredentials<Provider> | null) => OutNameOutput<Provider>;

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-browser-instance.d.ts

@@ -1,16 +1,9 @@
-import type { ChromiumOptions, LogLevel, openBrowser } from '@remotion/renderer';
+import type { LogLevel, openBrowser } from '@remotion/renderer';
 import type { Await } from './await';
-import type { ProviderSpecifics } from './provider-implementation';
-import type { CloudProvider } from './still';
-type LaunchedBrowser = {
+import type { GetBrowserInstance } from './provider-implementation';
+export type LaunchedBrowser = {
     instance: Await<ReturnType<typeof openBrowser>>;
     configurationString: string;
 };
-export declare const forgetBrowserEventLoop: (logLevel: LogLevel) => void;
-export declare const getBrowserInstance: <Provider extends CloudProvider>({ logLevel, indent, chromiumOptions, providerSpecifics, }: {
-    logLevel: LogLevel;
-    indent: boolean;
-    chromiumOptions: ChromiumOptions;
-    providerSpecifics: ProviderSpecifics<Provider>;
-}) => Promise<LaunchedBrowser>;
-export {};
+export declare const forgetBrowserEventLoopImplementation: (logLevel: LogLevel) => void;
+export declare const getBrowserInstanceImplementation: GetBrowserInstance;

package/dist/get-browser-instance.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBrowserInstance = exports.forgetBrowserEventLoop = void 0;
+exports.getBrowserInstanceImplementation = exports.forgetBrowserEventLoopImplementation = void 0;
 const renderer_1 = require("@remotion/renderer");
 const version_1 = require("remotion/version");
 const makeConfigurationString = (options, logLevel) => {
@@ -31,13 +31,13 @@ const waitForLaunched = () => {
         check();
     });
 };
-const forgetBrowserEventLoop = (logLevel) => {
+const forgetBrowserEventLoopImplementation = (logLevel) => {
     renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Keeping browser open for next invocation');
     _browserInstance === null || _browserInstance === void 0 ? void 0 : _browserInstance.instance.runner.forgetEventLoop();
     _browserInstance === null || _browserInstance === void 0 ? void 0 : _browserInstance.instance.runner.deleteBrowserCaches();
 };
-exports.forgetBrowserEventLoop = forgetBrowserEventLoop;
-const getBrowserInstance = async ({ logLevel, indent, chromiumOptions, providerSpecifics, }) => {
+exports.forgetBrowserEventLoopImplementation = forgetBrowserEventLoopImplementation;
+const getBrowserInstanceImplementation = async ({ logLevel, indent, chromiumOptions, providerSpecifics, insideFunctionSpecifics, }) => {
     var _a;
     const actualChromiumOptions = {
         ...chromiumOptions,
@@ -73,7 +73,7 @@ const getBrowserInstance = async ({ logLevel, indent, chromiumOptions, providerS
         instance.on('disconnected', () => {
             var _a;
             renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Browser disconnected or crashed.');
-            (0, exports.forgetBrowserEventLoop)(logLevel);
+            insideFunctionSpecifics.forgetBrowserEventLoop(logLevel);
             (_a = _browserInstance === null || _browserInstance === void 0 ? void 0 : _browserInstance.instance) === null || _a === void 0 ? void 0 : _a.close(true, logLevel, indent).catch((err) => {
                 renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Could not close browser instance', err);
             });
@@ -91,15 +91,16 @@ const getBrowserInstance = async ({ logLevel, indent, chromiumOptions, providerS
         _browserInstance.instance.runner.rememberEventLoop();
         await _browserInstance.instance.close(true, logLevel, indent);
         _browserInstance = null;
-        return (0, exports.getBrowserInstance)({
+        return insideFunctionSpecifics.getBrowserInstance({
             logLevel,
             indent,
             chromiumOptions,
             providerSpecifics,
+            insideFunctionSpecifics,
         });
     }
     renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Warm function, reusing browser instance');
     _browserInstance.instance.runner.rememberEventLoop();
     return _browserInstance;
 };
-exports.getBrowserInstance = getBrowserInstance;
+exports.getBrowserInstanceImplementation = getBrowserInstanceImplementation;

package/dist/get-custom-out-name.d.ts

@@ -1,6 +1,6 @@
 import type { CustomCredentials, OutNameInput } from './constants';
 import type { RenderMetadata } from './render-metadata';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 export declare const getCustomOutName: <Provider extends CloudProvider>({ renderMetadata, customCredentials, }: {
     renderMetadata: RenderMetadata<Provider>;
     customCredentials: CustomCredentials<Provider> | null;

package/dist/get-or-create-bucket.d.ts

@@ -1,6 +1,6 @@
 import type { CustomCredentials } from './constants';
 import type { ProviderSpecifics } from './provider-implementation';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 type GetOrCreateBucketInputInner<Provider extends CloudProvider> = {
     region: Provider['region'];
     enableFolderExpiry: boolean | null;

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/check-version-mismatch.d.ts

@@ -0,0 +1,8 @@
+import { type ServerlessPayload } from '../constants';
+import type { InsideFunctionSpecifics } from '../provider-implementation';
+import type { CloudProvider } from '../types';
+export declare const checkVersionMismatch: <Provider extends CloudProvider>({ params, insideFunctionSpecifics, apiName, }: {
+    params: ServerlessPayload<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+    apiName: string;
+}) => void;

package/dist/handlers/check-version-mismatch.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkVersionMismatch = void 0;
+const version_1 = require("remotion/version");
+const constants_1 = require("../constants");
+const checkVersionMismatch = ({ params, insideFunctionSpecifics, apiName, }) => {
+    if (params.type === constants_1.ServerlessRoutines.info) {
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.renderer) {
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.launch) {
+        return;
+    }
+    if (params.version !== version_1.VERSION) {
+        if (!params.version) {
+            throw new Error(`Version mismatch: When calling ${apiName}, you called the function ${insideFunctionSpecifics.getCurrentFunctionName()} which has the version ${version_1.VERSION} but the @remotion/lambda package is an older version. Deploy a new function and use it to call ${apiName}. See: https://www.remotion.dev/docs/lambda/upgrading`);
+        }
+        throw new Error(`Version mismatch: When calling ${apiName}, you passed ${insideFunctionSpecifics.getCurrentFunctionName()} as the function, which has the version ${version_1.VERSION}, but the @remotion/lambda package you used to invoke the function has version ${params.version}. Deploy a new function and use it to call getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
+    }
+};
+exports.checkVersionMismatch = checkVersionMismatch;

package/dist/handlers/compositions.d.ts

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

package/dist/handlers/compositions.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositionsHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const compress_props_1 = require("../compress-props");
+const constants_1 = require("../constants");
+const get_or_create_bucket_1 = require("../get-or-create-bucket");
+const check_version_mismatch_1 = require("./check-version-mismatch");
+const compositionsHandler = async ({ params, options, providerSpecifics, insideFunctionSpecifics, }) => {
+    var _a;
+    if (params.type !== constants_1.ServerlessRoutines.compositions) {
+        throw new TypeError('Expected info compositions');
+    }
+    (0, check_version_mismatch_1.checkVersionMismatch)({
+        apiName: 'getCompositionsOnLambda()',
+        insideFunctionSpecifics,
+        params,
+    });
+    try {
+        const region = providerSpecifics.getCurrentRegionInFunction();
+        const browserInstancePromise = insideFunctionSpecifics.getBrowserInstance({
+            logLevel: params.logLevel,
+            indent: false,
+            chromiumOptions: params.chromiumOptions,
+            providerSpecifics,
+            insideFunctionSpecifics,
+        });
+        const bucketNamePromise = params.bucketName
+            ? Promise.resolve(params.bucketName)
+            : (0, get_or_create_bucket_1.internalGetOrCreateBucket)({
+                region,
+                enableFolderExpiry: null,
+                customCredentials: null,
+                providerSpecifics,
+                forcePathStyle: params.forcePathStyle,
+                skipPutAcl: false,
+            }).then((b) => b.bucketName);
+        const bucketName = await bucketNamePromise;
+        const serializedInputPropsWithCustomSchema = await (0, compress_props_1.decompressInputProps)({
+            bucketName: await bucketNamePromise,
+            expectedBucketOwner: options.expectedBucketOwner,
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            serialized: params.inputProps,
+            propsType: 'input-props',
+            providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+        });
+        const realServeUrl = providerSpecifics.convertToServeUrl({
+            urlOrId: params.serveUrl,
+            region,
+            bucketName,
+        });
+        const compositions = await renderer_1.RenderInternals.internalGetCompositions({
+            serveUrlOrWebpackUrl: realServeUrl,
+            puppeteerInstance: (await browserInstancePromise).instance,
+            serializedInputPropsWithCustomSchema,
+            envVariables: (_a = params.envVariables) !== null && _a !== void 0 ? _a : {},
+            timeoutInMilliseconds: params.timeoutInMilliseconds,
+            chromiumOptions: params.chromiumOptions,
+            port: null,
+            server: undefined,
+            logLevel: params.logLevel,
+            indent: false,
+            browserExecutable: null,
+            onBrowserLog: null,
+            offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+            binariesDirectory: null,
+            onBrowserDownload: () => {
+                throw new Error('Should not download a browser in a function');
+            },
+        });
+        return Promise.resolve({
+            compositions,
+            type: 'success',
+        });
+    }
+    finally {
+        insideFunctionSpecifics.forgetBrowserEventLoop(params.logLevel);
+    }
+};
+exports.compositionsHandler = compositionsHandler;

package/dist/handlers/launch.d.ts

@@ -0,0 +1,18 @@
+import type { ServerlessPayload } from '../constants';
+import type { WebhookClient } from '../invoke-webhook';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from '../provider-implementation';
+import type { CloudProvider } from '../types';
+type Options = {
+    expectedBucketOwner: string;
+    getRemainingTimeInMillis: () => number;
+};
+export declare const launchHandler: <Provider extends CloudProvider>({ params, options, providerSpecifics, client, insideFunctionSpecifics, }: {
+    params: ServerlessPayload<Provider>;
+    options: Options;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+    client: WebhookClient;
+}) => Promise<{
+    type: "success";
+}>;
+export {};