@remotion/lambda 4.0.187 → 4.0.189

package/dist/functions/index.js

@@ -1,24 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handler = exports.routine = void 0;
+exports.handler = exports.routine = exports.innerRoutine = void 0;
 const renderer_1 = require("@remotion/renderer");
+const serverless_1 = require("@remotion/serverless");
+const client_1 = require("@remotion/serverless/client");
 const constants_1 = require("../shared/constants");
-const compositions_1 = require("./compositions");
+const aws_implementation_1 = require("./aws-implementation");
 const clean_tmpdir_1 = require("./helpers/clean-tmpdir");
 const is_warm_1 = require("./helpers/is-warm");
 const leak_detection_1 = require("./helpers/leak-detection");
 const lifecycle_1 = require("./helpers/lifecycle");
-const print_cloudwatch_helper_1 = require("./helpers/print-cloudwatch-helper");
+const print_logging_helper_1 = require("./helpers/print-logging-helper");
 const streamify_response_1 = require("./helpers/streamify-response");
-const info_1 = require("./info");
 const launch_1 = require("./launch");
 const progress_1 = require("./progress");
 const renderer_2 = require("./renderer");
 const start_1 = require("./start");
 const still_1 = require("./still");
-const stream_writer_1 = require("./streaming/stream-writer");
-const streaming_1 = require("./streaming/streaming");
-const innerHandler = async ({ params, responseWriter, context, }) => {
+const innerHandler = async ({ params, responseWriter, context, providerSpecifics, }) => {
     (0, leak_detection_1.setCurrentRequestId)(context.awsRequestId);
     process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
     const timeoutInMilliseconds = context.getRemainingTimeInMillis();
@@ -31,18 +30,20 @@ const innerHandler = async ({ params, responseWriter, context, }) => {
     const isWarm = (0, is_warm_1.getWarm)();
     (0, is_warm_1.setWarm)();
     const currentUserId = context.invokedFunctionArn.split(':')[4];
-    if (params.type === constants_1.LambdaRoutines.still) {
+    if (params.type === client_1.ServerlessRoutines.still) {
         (0, lifecycle_1.validateDeleteAfter)(params.deleteAfter);
-        const renderId = (0, lifecycle_1.generateRandomHashWithLifeCycleRule)(params.deleteAfter);
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.still, {
-            renderId,
-            inputProps: JSON.stringify(params.inputProps),
-            isWarm,
-        }, params.logLevel);
+        const renderId = (0, lifecycle_1.generateRandomHashWithLifeCycleRule)(params.deleteAfter, providerSpecifics);
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.still, {
+                renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
         try {
             await new Promise((resolve, reject) => {
                 const onStream = (payload) => {
-                    const message = (0, streaming_1.makeStreamPayload)({
+                    const message = (0, client_1.makeStreamPayload)({
                         message: payload,
                     });
                     return new Promise((innerResolve, innerReject) => {
@@ -69,6 +70,7 @@ const innerHandler = async ({ params, responseWriter, context, }) => {
                     renderId,
                     onStream,
                     timeoutInMilliseconds,
+                    providerSpecifics,
                 })
                     .then((r) => {
                     resolve(r);
@@ -84,75 +86,90 @@ const innerHandler = async ({ params, responseWriter, context, }) => {
         }
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.start) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.start, {
-            inputProps: JSON.stringify(params.inputProps),
-            isWarm,
-        }, params.logLevel);
+    if (params.type === client_1.ServerlessRoutines.start) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.start, {
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
         const response = await (0, start_1.startHandler)(params, {
             expectedBucketOwner: currentUserId,
             timeoutInMilliseconds,
-        });
+        }, providerSpecifics);
         await responseWriter.write(Buffer.from(JSON.stringify(response)));
         await responseWriter.end();
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.launch) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.launch, {
-            renderId: params.renderId,
-            inputProps: JSON.stringify(params.inputProps),
-            isWarm,
-        }, params.logLevel);
+    if (params.type === client_1.ServerlessRoutines.launch) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.launch, {
+                renderId: params.renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
         const response = await (0, launch_1.launchHandler)(params, {
             expectedBucketOwner: currentUserId,
             getRemainingTimeInMillis: context.getRemainingTimeInMillis,
-        });
+        }, providerSpecifics);
         await responseWriter.write(Buffer.from(JSON.stringify(response)));
         await responseWriter.end();
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.status) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.status, {
-            renderId: params.renderId,
-            isWarm,
-        }, params.logLevel);
+    if (params.type === client_1.ServerlessRoutines.status) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.status, {
+                renderId: params.renderId,
+                isWarm,
+            }, params.logLevel);
+        }
         const response = await (0, progress_1.progressHandler)(params, {
             expectedBucketOwner: currentUserId,
             timeoutInMilliseconds,
             retriesRemaining: 2,
+            providerSpecifics,
         });
         await responseWriter.write(Buffer.from(JSON.stringify(response)));
         await responseWriter.end();
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.renderer) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.renderer, {
-            renderId: params.renderId,
-            chunk: String(params.chunk),
-            dumpLogs: String(renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose')),
-            resolvedProps: JSON.stringify(params.resolvedProps),
-            isWarm,
-        }, params.logLevel);
-        await new Promise((resolve, reject) => {
-            (0, renderer_2.rendererHandler)(params, {
-                expectedBucketOwner: currentUserId,
+    if (params.type === client_1.ServerlessRoutines.renderer) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.renderer, {
+                renderId: params.renderId,
+                chunk: String(params.chunk),
+                dumpLogs: String(renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose')),
+                resolvedProps: JSON.stringify(params.resolvedProps),
                 isWarm,
-            }, (payload) => {
-                const message = (0, streaming_1.makeStreamPayload)({
-                    message: payload,
-                });
-                const writeProm = responseWriter.write(message);
-                return new Promise((innerResolve, innerReject) => {
-                    writeProm
-                        .then(() => {
-                        innerResolve();
-                    })
-                        .catch((err) => {
-                        reject(err);
-                        innerReject(err);
+            }, params.logLevel);
+        }
+        await new Promise((resolve, reject) => {
+            (0, renderer_2.rendererHandler)({
+                params,
+                options: {
+                    expectedBucketOwner: currentUserId,
+                    isWarm,
+                },
+                onStream: (payload) => {
+                    const message = (0, client_1.makeStreamPayload)({
+                        message: payload,
                     });
-                });
-            }, context)
+                    const writeProm = responseWriter.write(message);
+                    return new Promise((innerResolve, innerReject) => {
+                        writeProm
+                            .then(() => {
+                            innerResolve();
+                        })
+                            .catch((err) => {
+                            reject(err);
+                            innerReject(err);
+                        });
+                    });
+                },
+                requestContext: context,
+                providerSpecifics,
+            })
                 .then((res) => {
                 resolve(res);
             })
@@ -163,35 +180,40 @@ const innerHandler = async ({ params, responseWriter, context, }) => {
         await responseWriter.end();
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.info) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.info, {
-            isWarm,
-        }, params.logLevel);
-        const response = await (0, info_1.infoHandler)(params);
+    if (params.type === client_1.ServerlessRoutines.info) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.info, {
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, serverless_1.infoHandler)(params);
         await responseWriter.write(Buffer.from(JSON.stringify(response)));
         await responseWriter.end();
         return;
     }
-    if (params.type === constants_1.LambdaRoutines.compositions) {
-        (0, print_cloudwatch_helper_1.printCloudwatchHelper)(constants_1.LambdaRoutines.compositions, {
-            isWarm,
-        }, params.logLevel);
-        const response = await (0, compositions_1.compositionsHandler)(params, {
+    if (params.type === client_1.ServerlessRoutines.compositions) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.compositions, {
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, serverless_1.compositionsHandler)(params, {
             expectedBucketOwner: currentUserId,
-        });
+        }, providerSpecifics);
         await responseWriter.write(Buffer.from(JSON.stringify(response)));
         await responseWriter.end();
         return;
     }
     throw new Error(constants_1.COMMAND_NOT_FOUND);
 };
-const routine = async (params, responseStream, context) => {
-    const responseWriter = (0, stream_writer_1.streamWriter)(responseStream);
+const innerRoutine = async (params, responseStream, context, providerSpecifics) => {
+    const responseWriter = (0, serverless_1.streamWriter)(responseStream);
     try {
         await innerHandler({
             params,
             responseWriter,
             context,
+            providerSpecifics,
         });
     }
     catch (err) {
@@ -204,5 +226,9 @@ const routine = async (params, responseStream, context) => {
         await responseWriter.end();
     }
 };
+exports.innerRoutine = innerRoutine;
+const routine = (params, responseStream, context) => {
+    return (0, exports.innerRoutine)(params, responseStream, context, aws_implementation_1.awsImplementation);
+};
 exports.routine = routine;
 exports.handler = (0, streamify_response_1.streamifyResponse)(exports.routine);

package/dist/functions/info.d.ts

@@ -1,4 +1,4 @@
-import type { LambdaPayload } from '../shared/constants';
+import type { LambdaPayload } from '@remotion/serverless/client';
 export declare const infoHandler: (lambdaParams: LambdaPayload) => Promise<{
     version: string;
     type: "success";

package/dist/functions/info.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.infoHandler = void 0;
+const client_1 = require("@remotion/serverless/client");
 const version_1 = require("remotion/version");
-const constants_1 = require("../shared/constants");
 const infoHandler = (lambdaParams) => {
-    if (lambdaParams.type !== constants_1.LambdaRoutines.info) {
+    if (lambdaParams.type !== client_1.LambdaRoutines.info) {
         throw new TypeError('Expected info type');
     }
     const returnValue = {

package/dist/functions/launch.d.ts

@@ -1,9 +1,10 @@
-import type { LambdaPayload } from '../shared/constants';
+import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
 type Options = {
     expectedBucketOwner: string;
     getRemainingTimeInMillis: () => number;
 };
-export declare const launchHandler: (params: LambdaPayload, options: Options) => Promise<{
+export declare const launchHandler: <Provider extends CloudProvider<string, Record<string, unknown>>>(params: ServerlessPayload<Provider>, options: Options, providerSpecifics: ProviderSpecifics<Provider>) => Promise<{
     type: 'success';
 }>;
 export {};

package/dist/functions/launch.js

@@ -2,44 +2,44 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.launchHandler = void 0;
 const renderer_1 = require("@remotion/renderer");
+const serverless_1 = require("@remotion/serverless");
+const client_1 = require("@remotion/serverless/client");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const version_1 = require("remotion/version");
-const compress_props_1 = require("../shared/compress-props");
 const constants_1 = require("../shared/constants");
 const docs_url_1 = require("../shared/docs-url");
 const invoke_webhook_1 = require("../shared/invoke-webhook");
 const validate_1 = require("../shared/validate");
 const validate_frames_per_lambda_1 = require("../shared/validate-frames-per-lambda");
-const validate_outname_1 = require("../shared/validate-outname");
 const validate_privacy_1 = require("../shared/validate-privacy");
 const plan_frame_ranges_1 = require("./chunk-optimization/plan-frame-ranges");
 const best_frames_per_lambda_param_1 = require("./helpers/best-frames-per-lambda-param");
 const cleanup_props_1 = require("./helpers/cleanup-props");
-const expected_out_name_1 = require("./helpers/expected-out-name");
 const find_output_file_in_bucket_1 = require("./helpers/find-output-file-in-bucket");
-const get_browser_instance_1 = require("./helpers/get-browser-instance");
-const get_current_region_1 = require("./helpers/get-current-region");
-const io_1 = require("./helpers/io");
 const merge_chunks_1 = require("./helpers/merge-chunks");
 const overall_render_progress_1 = require("./helpers/overall-render-progress");
 const stream_renderer_1 = require("./helpers/stream-renderer");
 const timer_1 = require("./helpers/timer");
-const validate_composition_1 = require("./helpers/validate-composition");
-const write_lambda_error_1 = require("./helpers/write-lambda-error");
-const innerLaunchHandler = async ({ functionName, params, options, overallProgress, registerCleanupTask, }) => {
+const innerLaunchHandler = async ({ functionName, params, options, overallProgress, registerCleanupTask, providerSpecifics, }) => {
     var _a, _b, _c, _d, _e;
-    if (params.type !== constants_1.LambdaRoutines.launch) {
+    if (params.type !== client_1.ServerlessRoutines.launch) {
         throw new Error('Expected launch type');
     }
     const startedDate = Date.now();
-    const browserInstance = (0, get_browser_instance_1.getBrowserInstance)(params.logLevel, false, params.chromiumOptions);
-    const inputPropsPromise = (0, compress_props_1.decompressInputProps)({
+    const browserInstance = (0, serverless_1.getBrowserInstance)({
+        logLevel: params.logLevel,
+        indent: false,
+        chromiumOptions: params.chromiumOptions,
+        providerSpecifics,
+    });
+    const inputPropsPromise = (0, client_1.decompressInputProps)({
         bucketName: params.bucketName,
         expectedBucketOwner: options.expectedBucketOwner,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        region: providerSpecifics.getCurrentRegionInFunction(),
         serialized: params.inputProps,
         propsType: 'input-props',
+        providerSpecifics,
     });
     const logOptions = {
         indent: false,
@@ -50,7 +50,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
     const { instance } = await browserInstance;
     renderer_1.RenderInternals.Log.info(logOptions, 'Validating composition, input props:', serializedInputPropsWithCustomSchema);
     const startTime = Date.now();
-    const comp = await (0, validate_composition_1.validateComposition)({
+    const comp = await (0, serverless_1.validateComposition)({
         serveUrl: params.serveUrl,
         composition: params.composition,
         browserInstance: instance,
@@ -70,6 +70,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         onServeUrlVisited: () => {
             overallProgress.setServeUrlOpened(Date.now());
         },
+        providerSpecifics,
     });
     overallProgress.setCompositionValidated(Date.now());
     renderer_1.RenderInternals.Log.info(logOptions, 'Composition validated, resolved props', comp.props);
@@ -94,7 +95,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         framesPerLambda,
         durationInFrames: frameCount.length,
     });
-    (0, validate_outname_1.validateOutname)({
+    (0, serverless_1.validateOutname)({
         outName: params.outName,
         codec: params.codec,
         audioCodecSetting: params.audioCodec,
@@ -112,24 +113,26 @@ 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', [
+    const serializedResolved = (0, client_1.serializeOrThrow)(comp.props, 'resolved-props');
+    const needsToUpload = (0, client_1.getNeedsToUpload)('video-or-audio', [
         serializedResolved.length,
         params.inputProps.type === 'bucket-url'
             ? params.inputProps.hash.length
             : params.inputProps.payload.length,
     ]);
-    const serializedResolvedProps = await (0, compress_props_1.compressInputProps)({
+    const serializedResolvedProps = await (0, client_1.compressInputProps)({
         propsType: 'resolved-props',
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        region: providerSpecifics.getCurrentRegionInFunction(),
         stringifiedInputProps: serializedResolved,
         userSpecifiedBucketName: params.bucketName,
         needsToUpload,
+        providerSpecifics,
     });
     registerCleanupTask(() => {
         return (0, cleanup_props_1.cleanupProps)({
             serializedResolvedProps,
             inputProps: params.inputProps,
+            providerSpecifics,
         });
     });
     const fps = comp.fps / params.everyNthFrame;
@@ -139,7 +142,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
     const lambdaPayloads = chunks.map((chunkPayload) => {
         var _a;
         const payload = {
-            type: constants_1.LambdaRoutines.renderer,
+            type: client_1.ServerlessRoutines.renderer,
             frameRange: chunkPayload,
             serveUrl: params.serveUrl,
             chunk: sortedChunks.indexOf(chunkPayload),
@@ -207,7 +210,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         lambdaVersion: version_1.VERSION,
         framesPerLambda,
         memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        region: providerSpecifics.getCurrentRegionInFunction(),
         renderId: params.renderId,
         outName: (_c = params.outName) !== null && _c !== void 0 ? _c : undefined,
         privacy: params.privacy,
@@ -219,8 +222,9 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         downloadBehavior: params.downloadBehavior,
         audioBitrate: params.audioBitrate,
         muted: params.muted,
+        functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
     };
-    const { key, renderBucketName, customCredentials } = (0, expected_out_name_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
+    const { key, renderBucketName, customCredentials } = (0, client_1.getExpectedOutName)(renderMetadata, params.bucketName, typeof params.outName === 'string' || typeof params.outName === 'undefined'
         ? null
         : (_e = (_d = params.outName) === null || _d === void 0 ? void 0 : _d.s3OutputProvider) !== null && _e !== void 0 ? _e : null);
     if (!params.overwrite) {
@@ -229,10 +233,12 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
             bucketName: params.bucketName,
             customCredentials,
             renderMetadata,
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            currentRegion: providerSpecifics.getCurrentRegionInFunction(),
+            providerSpecifics,
         });
         if (output) {
-            throw new TypeError(`Output file "${key}" in bucket "${renderBucketName}" in region "${(0, get_current_region_1.getCurrentRegionInFunction)()}" already exists. Delete it before re-rendering, or set the 'overwrite' option in renderMediaOnLambda() to overwrite it."`);
+            throw new TypeError(`Output file "${key}" in bucket "${renderBucketName}" in region "${providerSpecifics.getCurrentRegionInFunction()}" already exists. Delete it before re-rendering, or set the 'overwrite' option in renderMediaOnLambda() to overwrite it."`);
         }
         findOutputFile.end();
     }
@@ -251,13 +257,14 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
             .find((a) => a.filename === artifact.filename)) {
             return { alreadyExisted: true };
         }
-        const region = (0, get_current_region_1.getCurrentRegionInFunction)();
-        const s3Key = (0, constants_1.artifactName)(renderMetadata.renderId, artifact.filename);
+        const region = providerSpecifics.getCurrentRegionInFunction();
+        const storageKey = (0, client_1.artifactName)(renderMetadata.renderId, artifact.filename);
         const start = Date.now();
         renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, 'Writing artifact ' + artifact.filename + ' to S3');
-        (0, io_1.lambdaWriteFile)({
+        providerSpecifics
+            .writeFile({
             bucketName: renderBucketName,
-            key: s3Key,
+            key: storageKey,
             body: artifact.content,
             region,
             privacy: params.privacy,
@@ -267,12 +274,12 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         })
             .then(() => {
             renderer_1.RenderInternals.Log.info({ indent: false, logLevel: params.logLevel }, `Wrote artifact to S3 in ${Date.now() - start}ms`);
-            overallProgress.addReceivedArtifact({
-                filename: artifact.filename,
-                sizeInBytes: artifact.content.length,
-                s3Url: `https://s3.${region}.amazonaws.com/${renderBucketName}/${s3Key}`,
-                s3Key,
-            });
+            overallProgress.addReceivedArtifact(providerSpecifics.makeArtifactWithDetails({
+                region,
+                renderBucketName,
+                storageKey,
+                artifact,
+            }));
         })
             .catch((err) => {
             overallProgress.addErrorWithoutUpload({
@@ -302,6 +309,7 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
             payload,
             logLevel: params.logLevel,
             onArtifact,
+            providerSpecifics,
         });
     }));
     const postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
@@ -332,12 +340,13 @@ const innerLaunchHandler = async ({ functionName, params, options, overallProgre
         files: files.sort(),
         overallProgress,
         startTime,
+        providerSpecifics,
     });
     return postRenderData;
 };
-const launchHandler = async (params, options) => {
+const launchHandler = async (params, options, providerSpecifics) => {
     var _a, _b, _c;
-    if (params.type !== constants_1.LambdaRoutines.launch) {
+    if (params.type !== client_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;
@@ -363,8 +372,11 @@ const launchHandler = async (params, options) => {
     const onTimeout = async () => {
         var _a;
         renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Function is about to time out. Can not finish render.');
-        // @ts-expect-error
-        globalThis._dumpUnreleasedBuffers.emit('dump-unreleased-buffers');
+        // @ts-expect-error - We are adding a listener to a global variable
+        if (globalThis._dumpUnreleasedBuffers) {
+            // @ts-expect-error - We are adding a listener to a global variable
+            globalThis._dumpUnreleasedBuffers.emit('dump-unreleased-buffers');
+        }
         runCleanupTasks();
         if (!params.webhook) {
             renderer_1.RenderInternals.Log.verbose({
@@ -428,9 +440,10 @@ const launchHandler = async (params, options) => {
         renderId: params.renderId,
         bucketName: params.bucketName,
         expectedBucketOwner: options.expectedBucketOwner,
-        region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+        region: providerSpecifics.getCurrentRegionInFunction(),
         timeoutTimestamp: options.getRemainingTimeInMillis() + Date.now(),
         logLevel: params.logLevel,
+        providerSpecifics,
     });
     try {
         const postRenderData = await innerLaunchHandler({
@@ -439,6 +452,7 @@ const launchHandler = async (params, options) => {
             options,
             overallProgress,
             registerCleanupTask,
+            providerSpecifics,
         });
         clearTimeout(webhookDueToTimeout);
         if (!params.webhook || webhookInvoked) {
@@ -504,7 +518,7 @@ const launchHandler = async (params, options) => {
             stack: err.stack,
             type: 'stitcher',
             isFatal: true,
-            tmpDir: (0, write_lambda_error_1.getTmpDirStateIfENoSp)(err.stack),
+            tmpDir: (0, serverless_1.getTmpDirStateIfENoSp)(err.stack, providerSpecifics),
             attempt: 1,
             totalAttempts: 1,
             willRetry: false,
@@ -560,7 +574,7 @@ const launchHandler = async (params, options) => {
         throw err;
     }
     finally {
-        (0, get_browser_instance_1.forgetBrowserEventLoop)(params.logLevel);
+        (0, serverless_1.forgetBrowserEventLoop)(params.logLevel);
     }
 };
 exports.launchHandler = launchHandler;

package/dist/functions/progress.d.ts

@@ -1,8 +1,11 @@
-import type { LambdaPayload, RenderProgress } from '../shared/constants';
-type Options = {
+import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
+import type { GenericRenderProgress } from '../shared/constants';
+type Options<Provider extends CloudProvider> = {
     expectedBucketOwner: string;
     timeoutInMilliseconds: number;
     retriesRemaining: number;
+    providerSpecifics: ProviderSpecifics<Provider>;
 };
-export declare const progressHandler: (lambdaParams: LambdaPayload, options: Options) => Promise<RenderProgress>;
+export declare const progressHandler: <Provider extends CloudProvider<string, Record<string, unknown>>>(lambdaParams: ServerlessPayload<Provider>, options: Options<Provider>) => Promise<GenericRenderProgress<Provider>>;
 export {};

package/dist/functions/progress.js

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.progressHandler = void 0;
+const client_1 = require("@remotion/serverless/client");
 const version_1 = require("remotion/version");
-const constants_1 = require("../shared/constants");
-const get_current_region_1 = require("./helpers/get-current-region");
 const get_progress_1 = require("./helpers/get-progress");
 const progressHandler = async (lambdaParams, options) => {
     var _a;
-    if (lambdaParams.type !== constants_1.LambdaRoutines.status) {
+    if (lambdaParams.type !== client_1.ServerlessRoutines.status) {
         throw new TypeError('Expected status type');
     }
     if (lambdaParams.version !== version_1.VERSION) {
@@ -21,10 +20,11 @@ const progressHandler = async (lambdaParams, options) => {
             bucketName: lambdaParams.bucketName,
             renderId: lambdaParams.renderId,
             expectedBucketOwner: options.expectedBucketOwner,
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            region: options.providerSpecifics.getCurrentRegionInFunction(),
             memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
             timeoutInMilliseconds: options.timeoutInMilliseconds,
             customCredentials: (_a = lambdaParams.s3OutputProvider) !== null && _a !== void 0 ? _a : null,
+            providerSpecifics: options.providerSpecifics,
         });
         return progress;
     }
@@ -40,6 +40,7 @@ const progressHandler = async (lambdaParams, options) => {
                 expectedBucketOwner: options.expectedBucketOwner,
                 timeoutInMilliseconds: options.timeoutInMilliseconds,
                 retriesRemaining: options.retriesRemaining - 1,
+                providerSpecifics: options.providerSpecifics,
             });
         }
         throw err;

package/dist/functions/provider-implementation.js

@@ -0,0 +1 @@
+"use strict";

package/dist/functions/renderer.d.ts

@@ -1,11 +1,17 @@
-import type { LambdaPayload } from '../shared/constants';
+import type { CloudProvider, OnStream, ProviderSpecifics } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
 import type { RequestContext } from './helpers/request-context';
-import type { OnStream } from './streaming/streaming';
 type Options = {
     expectedBucketOwner: string;
     isWarm: boolean;
 };
-export declare const rendererHandler: (params: LambdaPayload, options: Options, onStream: OnStream, requestContext: RequestContext) => Promise<{
+export declare const rendererHandler: <Provider extends CloudProvider<string, Record<string, unknown>>>({ onStream, options, params, providerSpecifics, requestContext, }: {
+    params: ServerlessPayload<Provider>;
+    options: Options;
+    onStream: OnStream<Provider>;
+    requestContext: RequestContext;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => Promise<{
     type: 'success';
 }>;
 export {};