@remotion/serverless 4.0.245 → 4.0.246

package/dist/handlers/launch.d.ts

@@ -1,15 +1,16 @@
 import type { ServerlessPayload } from '../constants';
 import type { WebhookClient } from '../invoke-webhook';
-import type { ProviderSpecifics } from '../provider-implementation';
+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, }: {
+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";

package/dist/handlers/launch.js

@@ -17,23 +17,23 @@ const find_output_file_in_bucket_1 = require("../find-output-file-in-bucket");
 const merge_chunks_1 = require("../merge-chunks");
 const plan_frame_ranges_1 = require("../plan-frame-ranges");
 const stream_renderer_1 = require("../stream-renderer");
-const validate_1 = require("../validate");
 const validate_composition_1 = require("../validate-composition");
 const validate_frames_per_function_1 = require("../validate-frames-per-function");
 const validate_outname_1 = require("../validate-outname");
 const validate_privacy_1 = require("../validate-privacy");
-const write_lambda_error_1 = require("../write-lambda-error");
-const innerLaunchHandler = async ({ functionName, params, options, overallProgress, registerCleanupTask, providerSpecifics, }) => {
+const write_error_to_storage_1 = require("../write-error-to-storage");
+const innerLaunchHandler = async ({ functionName, params, options, overallProgress, registerCleanupTask, providerSpecifics, insideFunctionSpecifics, }) => {
     var _a, _b, _c, _d, _e, _f, _g, _h;
     if (params.type !== constants_1.ServerlessRoutines.launch) {
         throw new Error('Expected launch type');
     }
     const startedDate = Date.now();
-    const browserInstance = providerSpecifics.getBrowserInstance({
+    const browserInstance = insideFunctionSpecifics.getBrowserInstance({
         logLevel: params.logLevel,
         indent: false,
         chromiumOptions: params.chromiumOptions,
         providerSpecifics,
+        insideFunctionSpecifics,
     });
     const inputPropsPromise = (0, compress_props_1.decompressInputProps)({
         bucketName: params.bucketName,
@@ -68,7 +68,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         server: undefined,
         offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
         onBrowserDownload: () => {
-            throw new Error('Should not download a browser in Lambda');
+            throw new Error('Should not download a browser in a function');
         },
         onServeUrlVisited: () => {
             overallProgress.setServeUrlOpened(Date.now());
@@ -77,25 +77,18 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
     });
     overallProgress.setCompositionValidated(Date.now());
     renderer_1.RenderInternals.Log.info(logOptions, 'Composition validated, resolved props', comp.props);
-    (0, validate_1.validateDurationInFrames)(comp.durationInFrames, {
-        component: 'passed to a Lambda render',
-        allowFloats: false,
-    });
-    (0, validate_1.validateFps)(comp.fps, 'passed to a Lambda render', false);
-    (0, validate_1.validateDimension)(comp.height, 'height', 'passed to a Lambda render');
-    (0, validate_1.validateDimension)(comp.width, 'width', 'passed to a Lambda render');
     renderer_1.RenderInternals.validateBitrate(params.audioBitrate, 'audioBitrate');
     renderer_1.RenderInternals.validateBitrate(params.videoBitrate, 'videoBitrate');
     renderer_1.RenderInternals.validateConcurrency({
-        value: params.concurrencyPerLambda,
+        value: params.concurrencyPerFunction,
         setting: 'concurrencyPerLambda',
         checkIfValidForCurrentMachine: ((_b = params.rendererFunctionName) !== null && _b !== void 0 ? _b : null) === null,
     });
     const realFrameRange = renderer_1.RenderInternals.getRealFrameRange(comp.durationInFrames, params.frameRange);
     const frameCount = renderer_1.RenderInternals.getFramesToRender(realFrameRange, params.everyNthFrame);
-    const framesPerLambda = (_c = params.framesPerLambda) !== null && _c !== void 0 ? _c : (0, best_frames_per_function_param_1.bestFramesPerFunctionParam)(frameCount.length);
+    const framesPerLambda = (_c = params.framesPerFunction) !== null && _c !== void 0 ? _c : (0, best_frames_per_function_param_1.bestFramesPerFunctionParam)(frameCount.length);
     (0, validate_frames_per_function_1.validateFramesPerFunction)({
-        framesPerLambda,
+        framesPerFunction: framesPerLambda,
         durationInFrames: frameCount.length,
     });
     (0, validate_outname_1.validateOutname)({
@@ -107,7 +100,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
     (0, validate_privacy_1.validatePrivacy)(params.privacy, true);
     renderer_1.RenderInternals.validatePuppeteerTimeout(params.timeoutInMilliseconds);
     const { chunks } = (0, plan_frame_ranges_1.planFrameRanges)({
-        framesPerLambda,
+        framesPerFunction: framesPerLambda,
         frameRange: realFrameRange,
         everyNthFrame: params.everyNthFrame,
     });
@@ -117,13 +110,17 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
     overallProgress.setExpectedChunks(chunks.length);
     const sortedChunks = chunks.slice().sort((a, b) => a[0] - b[0]);
     const serializedResolved = (0, compress_props_1.serializeOrThrow)(comp.props, 'resolved-props');
-    const needsToUpload = (0, compress_props_1.getNeedsToUpload)('video-or-audio', [
-        serializedResolved.length,
-        params.inputProps.type === 'bucket-url'
-            ? params.inputProps.hash.length
-            : params.inputProps.payload.length,
-        JSON.stringify(params.envVariables).length,
-    ]);
+    const needsToUpload = (0, compress_props_1.getNeedsToUpload)({
+        type: 'video-or-audio',
+        sizes: [
+            serializedResolved.length,
+            params.inputProps.type === 'bucket-url'
+                ? params.inputProps.hash.length
+                : params.inputProps.payload.length,
+            JSON.stringify(params.envVariables).length,
+        ],
+        providerSpecifics,
+    });
     const serializedResolvedProps = await (0, compress_props_1.compressInputProps)({
         propsType: 'resolved-props',
         region: providerSpecifics.getCurrentRegionInFunction(),
@@ -177,7 +174,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
             chromiumOptions: params.chromiumOptions,
             scale: params.scale,
             everyNthFrame: params.everyNthFrame,
-            concurrencyPerLambda: params.concurrencyPerLambda,
+            concurrencyPerLambda: params.concurrencyPerFunction,
             muted: params.muted,
             audioBitrate: params.audioBitrate,
             videoBitrate: params.videoBitrate,
@@ -218,7 +215,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         inputProps: params.inputProps,
         lambdaVersion: version_1.VERSION,
         framesPerLambda,
-        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+        memorySizeInMb: insideFunctionSpecifics.getCurrentMemorySizeInMb(),
         region: providerSpecifics.getCurrentRegionInFunction(),
         renderId: params.renderId,
         outName: (_d = params.outName) !== null && _d !== void 0 ? _d : undefined,
@@ -232,7 +229,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         audioBitrate: params.audioBitrate,
         muted: params.muted,
         metadata: params.metadata,
-        functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+        functionName: insideFunctionSpecifics.getCurrentFunctionName(),
         dimensions: {
             width: comp.width * ((_e = params.scale) !== null && _e !== void 0 ? _e : 1),
             height: comp.height * ((_f = params.scale) !== null && _f !== void 0 ? _f : 1),
@@ -242,7 +239,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         ? null
         : ((_h = (_g = params.outName) === null || _g === void 0 ? void 0 : _g.s3OutputProvider) !== null && _h !== void 0 ? _h : null));
     if (!params.overwrite) {
-        const findOutputFile = providerSpecifics.timer('Checking if output file already exists', params.logLevel);
+        const findOutputFile = insideFunctionSpecifics.timer('Checking if output file already exists', params.logLevel);
         const output = await (0, find_output_file_in_bucket_1.findOutputFileInBucket)({
             bucketName: params.bucketName,
             customCredentials,
@@ -358,15 +355,16 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         startTime,
         providerSpecifics,
         forcePathStyle: params.forcePathStyle,
+        insideFunctionSpecifics,
     });
     return postRenderData;
 };
-const launchHandler = async ({ params, options, providerSpecifics, client, }) => {
+const launchHandler = async ({ params, options, providerSpecifics, client, insideFunctionSpecifics, }) => {
     var _a, _b, _c;
     if (params.type !== constants_1.ServerlessRoutines.launch) {
         throw new Error('Expected launch type');
     }
-    const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : process.env.AWS_LAMBDA_FUNCTION_NAME;
+    const functionName = (_a = params.rendererFunctionName) !== null && _a !== void 0 ? _a : insideFunctionSpecifics.getCurrentFunctionName();
     const logOptions = {
         indent: false,
         logLevel: params.logLevel,
@@ -472,6 +470,7 @@ const launchHandler = async ({ params, options, providerSpecifics, client, }) =>
             overallProgress,
             registerCleanupTask,
             providerSpecifics,
+            insideFunctionSpecifics,
         });
         clearTimeout(webhookDueToTimeout);
         if (!params.webhook || webhookInvoked) {
@@ -538,7 +537,7 @@ const launchHandler = async ({ params, options, providerSpecifics, client, }) =>
             stack: err.stack,
             type: 'stitcher',
             isFatal: true,
-            tmpDir: (0, write_lambda_error_1.getTmpDirStateIfENoSp)(err.stack, providerSpecifics),
+            tmpDir: (0, write_error_to_storage_1.getTmpDirStateIfENoSp)(err.stack, providerSpecifics),
             attempt: 1,
             totalAttempts: 1,
             willRetry: false,
@@ -595,7 +594,7 @@ const launchHandler = async ({ params, options, providerSpecifics, client, }) =>
         throw err;
     }
     finally {
-        providerSpecifics.forgetBrowserEventLoop(params.logLevel);
+        insideFunctionSpecifics.forgetBrowserEventLoop(params.logLevel);
     }
 };
 exports.launchHandler = launchHandler;

package/dist/handlers/progress.d.ts

@@ -1,5 +1,5 @@
 import type { ServerlessPayload } from '../constants';
-import type { ProviderSpecifics } from '../provider-implementation';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from '../provider-implementation';
 import type { GenericRenderProgress } from '../render-progress';
 import type { CloudProvider } from '../types';
 type Options<Provider extends CloudProvider> = {
@@ -7,6 +7,10 @@ type Options<Provider extends CloudProvider> = {
     timeoutInMilliseconds: number;
     retriesRemaining: number;
     providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
 };
-export declare const progressHandler: <Provider extends CloudProvider>(lambdaParams: ServerlessPayload<Provider>, options: Options<Provider>) => Promise<GenericRenderProgress<Provider>>;
+export declare const progressHandler: <Provider extends CloudProvider>({ params, options, }: {
+    params: ServerlessPayload<Provider>;
+    options: Options<Provider>;
+}) => Promise<GenericRenderProgress<Provider>>;
 export {};

package/dist/handlers/progress.js

@@ -1,32 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.progressHandler = void 0;
-const version_1 = require("remotion/version");
 const constants_1 = require("../constants");
 const progress_1 = require("../progress");
-const progressHandler = async (lambdaParams, options) => {
+const check_version_mismatch_1 = require("./check-version-mismatch");
+const progressHandler = async ({ params, options, }) => {
     var _a;
-    if (lambdaParams.type !== constants_1.ServerlessRoutines.status) {
+    if (params.type !== constants_1.ServerlessRoutines.status) {
         throw new TypeError('Expected status type');
     }
-    if (lambdaParams.version !== version_1.VERSION) {
-        if (!lambdaParams.version) {
-            throw new Error(`Version mismatch: When calling getRenderProgress(), you called the function ${process.env.AWS_LAMBDA_FUNCTION_NAME} 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 getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
-        }
-        throw new Error(`Version mismatch: When calling getRenderProgress(), you passed ${process.env.AWS_LAMBDA_FUNCTION_NAME} as the function, which has the version ${version_1.VERSION}, but the @remotion/lambda package you used to invoke the function has version ${lambdaParams.version}. Deploy a new function and use it to call getRenderProgress(). See: https://www.remotion.dev/docs/lambda/upgrading`);
-    }
+    (0, check_version_mismatch_1.checkVersionMismatch)({
+        apiName: 'getRenderProgress()',
+        insideFunctionSpecifics: options.insideFunctionSpecifics,
+        params,
+    });
     try {
         const progress = await (0, progress_1.getProgress)({
-            bucketName: lambdaParams.bucketName,
-            renderId: lambdaParams.renderId,
+            bucketName: params.bucketName,
+            renderId: params.renderId,
             expectedBucketOwner: options.expectedBucketOwner,
             region: options.providerSpecifics.getCurrentRegionInFunction(),
-            memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+            memorySizeInMb: options.insideFunctionSpecifics.getCurrentMemorySizeInMb(),
             timeoutInMilliseconds: options.timeoutInMilliseconds,
-            customCredentials: (_a = lambdaParams.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
+            customCredentials: (_a = params.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
             providerSpecifics: options.providerSpecifics,
-            forcePathStyle: lambdaParams.forcePathStyle,
-            functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+            forcePathStyle: params.forcePathStyle,
+            functionName: options.insideFunctionSpecifics.getCurrentFunctionName(),
         });
         return progress;
     }
@@ -38,11 +37,15 @@ const progressHandler = async (lambdaParams, options) => {
             await new Promise((resolve) => {
                 setTimeout(resolve, 1000);
             });
-            return (0, exports.progressHandler)(lambdaParams, {
-                expectedBucketOwner: options.expectedBucketOwner,
-                timeoutInMilliseconds: options.timeoutInMilliseconds,
-                retriesRemaining: options.retriesRemaining - 1,
-                providerSpecifics: options.providerSpecifics,
+            return (0, exports.progressHandler)({
+                params,
+                options: {
+                    expectedBucketOwner: options.expectedBucketOwner,
+                    timeoutInMilliseconds: options.timeoutInMilliseconds,
+                    retriesRemaining: options.retriesRemaining - 1,
+                    providerSpecifics: options.providerSpecifics,
+                    insideFunctionSpecifics: options.insideFunctionSpecifics,
+                },
             });
         }
         throw err;

package/dist/handlers/renderer.d.ts

@@ -1,5 +1,5 @@
 import type { ServerlessPayload } from '../constants';
-import type { ProviderSpecifics } from '../provider-implementation';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from '../provider-implementation';
 import type { OnStream } from '../streaming/streaming';
 import type { CloudProvider } from '../types';
 type Options = {
@@ -11,12 +11,13 @@ export type RequestContext = {
     getRemainingTimeInMillis: () => number;
     awsRequestId: string;
 };
-export declare const rendererHandler: <Provider extends CloudProvider>({ onStream, options, params, providerSpecifics, requestContext, }: {
+export declare const rendererHandler: <Provider extends CloudProvider>({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, }: {
     params: ServerlessPayload<Provider>;
     options: Options;
     onStream: OnStream<Provider>;
     requestContext: RequestContext;
     providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
 }) => Promise<{
     type: "success";
 }>;

package/dist/handlers/renderer.js

@@ -17,8 +17,8 @@ const on_downloads_helpers_1 = require("../on-downloads-helpers");
 const serialize_artifact_1 = require("../serialize-artifact");
 const truthy_1 = require("../truthy");
 const why_is_node_running_1 = require("../why-is-node-running");
-const write_lambda_error_1 = require("../write-lambda-error");
-const renderHandler = async ({ params, options, logs, onStream, providerSpecifics, }) => {
+const write_error_to_storage_1 = require("../write-error-to-storage");
+const renderHandler = async ({ params, options, logs, onStream, providerSpecifics, insideFunctionSpecifics, }) => {
     if (params.type !== constants_1.ServerlessRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -43,11 +43,12 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
         providerSpecifics,
         forcePathStyle: params.forcePathStyle,
     });
-    const browserInstance = await providerSpecifics.getBrowserInstance({
+    const browserInstance = await insideFunctionSpecifics.getBrowserInstance({
         logLevel: params.logLevel,
         indent: false,
         chromiumOptions: params.chromiumOptions,
         providerSpecifics,
+        insideFunctionSpecifics,
     });
     const outputPath = renderer_1.RenderInternals.tmpDir('remotion-render-');
     if (typeof params.chunk !== 'number') {
@@ -228,9 +229,9 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
         })
             .catch((err) => reject(err));
     });
-    const streamTimer = providerSpecifics.timer('Streaming chunk to the main function', params.logLevel);
+    const streamTimer = insideFunctionSpecifics.timer('Streaming chunk to the main function', params.logLevel);
     if (audioOutputLocation) {
-        const audioChunkTimer = providerSpecifics.timer('Sending audio chunk', params.logLevel);
+        const audioChunkTimer = insideFunctionSpecifics.timer('Sending audio chunk', params.logLevel);
         await onStream({
             type: 'audio-chunk-rendered',
             payload: node_fs_1.default.readFileSync(audioOutputLocation),
@@ -238,7 +239,7 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
         audioChunkTimer.end();
     }
     if (videoOutputLocation) {
-        const videoChunkTimer = providerSpecifics.timer('Sending main chunk', params.logLevel);
+        const videoChunkTimer = insideFunctionSpecifics.timer('Sending main chunk', params.logLevel);
         await onStream({
             type: pure_1.NoReactAPIs.isAudioCodec(params.codec)
                 ? 'audio-chunk-rendered'
@@ -268,7 +269,7 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
     return {};
 };
 const ENABLE_SLOW_LEAK_DETECTION = false;
-const rendererHandler = async ({ onStream, options, params, providerSpecifics, requestContext, }) => {
+const rendererHandler = async ({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, }) => {
     if (params.type !== constants_1.ServerlessRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -282,6 +283,7 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
             logs,
             onStream,
             providerSpecifics,
+            insideFunctionSpecifics,
         });
         return {
             type: 'success',
@@ -316,7 +318,7 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
                     frame: null,
                     type: 'renderer',
                     isFatal: !shouldRetry,
-                    tmpDir: (0, write_lambda_error_1.getTmpDirStateIfENoSp)(err.stack, providerSpecifics),
+                    tmpDir: (0, write_error_to_storage_1.getTmpDirStateIfENoSp)(err.stack, providerSpecifics),
                     attempt: params.attempt,
                     totalAttempts: params.retriesLeft + params.attempt,
                     willRetry: shouldRetry,
@@ -327,11 +329,11 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
     }
     finally {
         if (shouldKeepBrowserOpen) {
-            providerSpecifics.forgetBrowserEventLoop(params.logLevel);
+            insideFunctionSpecifics.forgetBrowserEventLoop(params.logLevel);
         }
         else {
-            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Lambda did not succeed with flaky error, not keeping browser open.');
-            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Quitting Lambda forcefully now to force not keeping the Lambda warm.');
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Function did not succeed with flaky error, not keeping browser open.');
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Quitting Function forcefully now to force not keeping the Function warm.');
             process.exit(0);
         }
         if (ENABLE_SLOW_LEAK_DETECTION) {

package/dist/handlers/start.d.ts

@@ -1,12 +1,17 @@
 import type { ServerlessPayload } from '../constants';
-import type { ProviderSpecifics } from '../provider-implementation';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from '../provider-implementation';
 import type { CloudProvider } from '../types';
 type Options = {
     expectedBucketOwner: string;
     timeoutInMilliseconds: number;
     renderId: string;
 };
-export declare const startHandler: <Provider extends CloudProvider>(params: ServerlessPayload<Provider>, options: Options, providerSpecifics: ProviderSpecifics<Provider>) => Promise<{
+export declare const startHandler: <Provider extends CloudProvider>({ params, options, providerSpecifics, insideFunctionSpecifics, }: {
+    params: ServerlessPayload<Provider>;
+    options: Options;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+}) => Promise<{
     type: "success";
     bucketName: string;
     renderId: string;

package/dist/handlers/start.js

@@ -1,21 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startHandler = void 0;
-const version_1 = require("remotion/version");
 const constants_1 = require("../constants");
 const get_or_create_bucket_1 = require("../get-or-create-bucket");
 const overall_render_progress_1 = require("../overall-render-progress");
-const startHandler = async (params, options, providerSpecifics) => {
+const check_version_mismatch_1 = require("./check-version-mismatch");
+const startHandler = async ({ params, options, providerSpecifics, insideFunctionSpecifics, }) => {
     var _a, _b, _c, _d;
     if (params.type !== constants_1.ServerlessRoutines.start) {
         throw new TypeError('Expected type start');
     }
-    if (params.version !== version_1.VERSION) {
-        if (!params.version) {
-            throw new Error(`Version mismatch: When calling renderMediaOnLambda(), you called the function ${process.env.AWS_LAMBDA_FUNCTION_NAME} 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 renderMediaOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
-        }
-        throw new Error(`Version mismatch: When calling renderMediaOnLambda(), you passed ${process.env.AWS_LAMBDA_FUNCTION_NAME} 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 renderMediaOnLambda(). See: https://www.remotion.dev/docs/lambda/upgrading`);
-    }
+    (0, check_version_mismatch_1.checkVersionMismatch)({
+        apiName: 'renderMediaOnLambda()',
+        insideFunctionSpecifics,
+        params,
+    });
     const region = providerSpecifics.getCurrentRegionInFunction();
     const bucketName = (_a = params.bucketName) !== null && _a !== void 0 ? _a : (await (0, get_or_create_bucket_1.internalGetOrCreateBucket)({
         region: providerSpecifics.getCurrentRegionInFunction(),
@@ -44,7 +43,7 @@ const startHandler = async (params, options, providerSpecifics) => {
     });
     const payload = {
         type: constants_1.ServerlessRoutines.launch,
-        framesPerLambda: params.framesPerLambda,
+        framesPerFunction: params.framesPerLambda,
         composition: params.composition,
         serveUrl: realServeUrl,
         inputProps: params.inputProps,
@@ -68,7 +67,7 @@ const startHandler = async (params, options, providerSpecifics) => {
         scale: params.scale,
         numberOfGifLoops: params.numberOfGifLoops,
         everyNthFrame: params.everyNthFrame,
-        concurrencyPerLambda: params.concurrencyPerLambda,
+        concurrencyPerFunction: params.concurrencyPerLambda,
         downloadBehavior: params.downloadBehavior,
         muted: params.muted,
         overwrite: params.overwrite,
@@ -89,7 +88,7 @@ const startHandler = async (params, options, providerSpecifics) => {
         metadata: params.metadata,
     };
     await providerSpecifics.callFunctionAsync({
-        functionName: providerSpecifics.getCurrentFunctionName(),
+        functionName: insideFunctionSpecifics.getCurrentFunctionName(),
         type: constants_1.ServerlessRoutines.launch,
         payload,
         region,

package/dist/handlers/still.d.ts

@@ -1,5 +1,5 @@
 import type { ServerlessPayload } from '../constants';
-import type { ProviderSpecifics } from '../provider-implementation';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from '../provider-implementation';
 import type { OnStream } from '../streaming/streaming';
 import type { CloudProvider } from '../types';
 type Options<Provider extends CloudProvider> = {
@@ -9,6 +9,7 @@ type Options<Provider extends CloudProvider> = {
     onStream: OnStream<Provider>;
     timeoutInMilliseconds: number;
     providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
 };
 export declare const stillHandler: <Provider extends CloudProvider>(options: Options<Provider>) => Promise<{
     type: "success";