@remotion/lambda 4.0.245 → 4.0.246

package/dist/client.d.ts

@@ -1,23 +1,18 @@
-import type { DeleteRenderInput } from './api/delete-render';
-import { deleteRender } from './api/delete-render';
-import { getCompositionsOnLambda } from './api/get-compositions-on-lambda';
-import { getFunctions } from './api/get-functions';
-import type { GetRenderProgressInput } from './api/get-render-progress';
-import { getRenderProgress } from './api/get-render-progress';
-import { getSites } from './api/get-sites';
-import type { PresignUrlInput } from './api/presign-url';
-import { presignUrl } from './api/presign-url';
-import type { RenderMediaOnLambdaInput, RenderMediaOnLambdaOutput } from './api/render-media-on-lambda';
-import { renderMediaOnLambda, renderVideoOnLambda } from './api/render-media-on-lambda';
-import type { RenderStillOnLambdaInput, RenderStillOnLambdaOutput } from './api/render-still-on-lambda';
-import { renderStillOnLambda } from './api/render-still-on-lambda';
-import type { SpeculateFunctionNameInput } from './api/speculate-function-name';
-import { speculateFunctionName } from './api/speculate-function-name';
-import { validateWebhookSignature } from './api/validate-webhook-signature';
-import type { RenderProgress } from './shared/constants';
-import type { WebhookPayload } from './shared/invoke-webhook';
-export { CustomCredentials, DeleteAfter } from '@remotion/serverless/client';
-export { getAwsClient, GetAwsClientInput, GetAwsClientOutput, } from './api/get-aws-client';
+export type { WebhookErrorPayload, WebhookPayload, WebhookSuccessPayload, WebhookTimeoutPayload, } from '@remotion/serverless';
+export type { CustomCredentials, DeleteAfter } from '@remotion/serverless/client';
+export { NextWebhookArgs, appRouterWebhook } from './api/app-router-webhook';
+export { deleteRender, type DeleteRenderInput } from './api/delete-render';
+export { getAwsClient, type GetAwsClientInput, type GetAwsClientOutput, } from './api/get-aws-client';
+export { getCompositionsOnLambda, type GetCompositionsOnLambdaInput, type GetCompositionsOnLambdaOutput, } from './api/get-compositions-on-lambda';
+export { getFunctions, type GetFunctionsInput } from './api/get-functions';
+export { getRenderProgress } from './api/get-render-progress';
+export type { GetRenderProgressInput } from './api/get-render-progress';
+export { getSites, type GetSitesInput, type GetSitesOutput, } from './api/get-sites';
+export { pagesRouterWebhook } from './api/pages-router-webhook';
+export { presignUrl, type PresignUrlInput } from './api/presign-url';
+export { renderMediaOnLambda, renderVideoOnLambda, type RenderMediaOnLambdaInput, type RenderMediaOnLambdaOutput, } from './api/render-media-on-lambda';
+export { renderStillOnLambda, type RenderStillOnLambdaInput, type RenderStillOnLambdaOutput, } from './api/render-still-on-lambda';
+export { speculateFunctionName, type SpeculateFunctionNameInput, } from './api/speculate-function-name';
+export { validateWebhookSignature } from './api/validate-webhook-signature';
 export type { AwsRegion } from './regions';
-export { deleteRender, getCompositionsOnLambda, getFunctions, getRenderProgress, getSites, presignUrl, renderMediaOnLambda, renderStillOnLambda, renderVideoOnLambda, speculateFunctionName, validateWebhookSignature, };
-export type { DeleteRenderInput, GetRenderProgressInput, PresignUrlInput, RenderMediaOnLambdaInput, RenderMediaOnLambdaOutput, RenderProgress, RenderStillOnLambdaInput, RenderStillOnLambdaOutput, SpeculateFunctionNameInput, WebhookPayload, };
+export type { RenderProgress } from './shared/constants';

package/dist/client.js

@@ -1,26 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateWebhookSignature = exports.speculateFunctionName = exports.renderVideoOnLambda = exports.renderStillOnLambda = exports.renderMediaOnLambda = exports.presignUrl = exports.getSites = exports.getRenderProgress = exports.getFunctions = exports.getCompositionsOnLambda = exports.deleteRender = exports.getAwsClient = void 0;
-const delete_render_1 = require("./api/delete-render");
+exports.validateWebhookSignature = exports.speculateFunctionName = exports.renderStillOnLambda = exports.renderVideoOnLambda = exports.renderMediaOnLambda = exports.presignUrl = exports.pagesRouterWebhook = exports.getSites = exports.getRenderProgress = exports.getFunctions = exports.getCompositionsOnLambda = exports.getAwsClient = exports.deleteRender = exports.appRouterWebhook = void 0;
+var app_router_webhook_1 = require("./api/app-router-webhook");
+Object.defineProperty(exports, "appRouterWebhook", { enumerable: true, get: function () { return app_router_webhook_1.appRouterWebhook; } });
+var delete_render_1 = require("./api/delete-render");
 Object.defineProperty(exports, "deleteRender", { enumerable: true, get: function () { return delete_render_1.deleteRender; } });
-const get_compositions_on_lambda_1 = require("./api/get-compositions-on-lambda");
+var get_aws_client_1 = require("./api/get-aws-client");
+Object.defineProperty(exports, "getAwsClient", { enumerable: true, get: function () { return get_aws_client_1.getAwsClient; } });
+var get_compositions_on_lambda_1 = require("./api/get-compositions-on-lambda");
 Object.defineProperty(exports, "getCompositionsOnLambda", { enumerable: true, get: function () { return get_compositions_on_lambda_1.getCompositionsOnLambda; } });
-const get_functions_1 = require("./api/get-functions");
+var get_functions_1 = require("./api/get-functions");
 Object.defineProperty(exports, "getFunctions", { enumerable: true, get: function () { return get_functions_1.getFunctions; } });
-const get_render_progress_1 = require("./api/get-render-progress");
+var get_render_progress_1 = require("./api/get-render-progress");
 Object.defineProperty(exports, "getRenderProgress", { enumerable: true, get: function () { return get_render_progress_1.getRenderProgress; } });
-const get_sites_1 = require("./api/get-sites");
+var get_sites_1 = require("./api/get-sites");
 Object.defineProperty(exports, "getSites", { enumerable: true, get: function () { return get_sites_1.getSites; } });
-const presign_url_1 = require("./api/presign-url");
+var pages_router_webhook_1 = require("./api/pages-router-webhook");
+Object.defineProperty(exports, "pagesRouterWebhook", { enumerable: true, get: function () { return pages_router_webhook_1.pagesRouterWebhook; } });
+var presign_url_1 = require("./api/presign-url");
 Object.defineProperty(exports, "presignUrl", { enumerable: true, get: function () { return presign_url_1.presignUrl; } });
-const render_media_on_lambda_1 = require("./api/render-media-on-lambda");
+var render_media_on_lambda_1 = require("./api/render-media-on-lambda");
 Object.defineProperty(exports, "renderMediaOnLambda", { enumerable: true, get: function () { return render_media_on_lambda_1.renderMediaOnLambda; } });
 Object.defineProperty(exports, "renderVideoOnLambda", { enumerable: true, get: function () { return render_media_on_lambda_1.renderVideoOnLambda; } });
-const render_still_on_lambda_1 = require("./api/render-still-on-lambda");
+var render_still_on_lambda_1 = require("./api/render-still-on-lambda");
 Object.defineProperty(exports, "renderStillOnLambda", { enumerable: true, get: function () { return render_still_on_lambda_1.renderStillOnLambda; } });
-const speculate_function_name_1 = require("./api/speculate-function-name");
+var speculate_function_name_1 = require("./api/speculate-function-name");
 Object.defineProperty(exports, "speculateFunctionName", { enumerable: true, get: function () { return speculate_function_name_1.speculateFunctionName; } });
-const validate_webhook_signature_1 = require("./api/validate-webhook-signature");
+var validate_webhook_signature_1 = require("./api/validate-webhook-signature");
 Object.defineProperty(exports, "validateWebhookSignature", { enumerable: true, get: function () { return validate_webhook_signature_1.validateWebhookSignature; } });
-var get_aws_client_1 = require("./api/get-aws-client");
-Object.defineProperty(exports, "getAwsClient", { enumerable: true, get: function () { return get_aws_client_1.getAwsClient; } });

package/dist/functions/aws-implementation.d.ts

@@ -1,5 +1,6 @@
-import { type ProviderSpecifics } from '@remotion/serverless';
+import type { ProviderSpecifics } from '@remotion/serverless';
 import type { AwsRegion } from '../regions';
+import type { RuntimePreference } from '../shared/get-layers';
 export type AwsProvider = {
     type: 'aws';
     region: AwsRegion;
@@ -7,5 +8,16 @@ export type AwsProvider = {
         s3Key: string;
         s3Url: string;
     };
+    creationFunctionOptions: {
+        createCloudWatchLogGroup: boolean;
+        accountId: string;
+        alreadyCreated: boolean;
+        retentionInDays: number;
+        customRoleArn: string;
+        enableLambdaInsights: boolean;
+        vpcSubnetIds: string;
+        vpcSecurityGroupIds: string;
+        runtimePreference: RuntimePreference;
+    };
 };
 export declare const awsImplementation: ProviderSpecifics<AwsProvider>;

package/dist/functions/aws-implementation.js

@@ -2,20 +2,32 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.awsImplementation = void 0;
+const client_1 = require("@remotion/serverless/client");
 const node_events_1 = require("node:events");
 const bucket_exists_1 = require("../api/bucket-exists");
 const create_bucket_1 = require("../api/create-bucket");
+const delete_function_1 = require("../api/delete-function");
+const estimate_price_1 = require("../api/estimate-price");
 const get_buckets_1 = require("../api/get-buckets");
+const get_functions_1 = require("../api/get-functions");
+const defaults_1 = require("../defaults");
 const delete_file_1 = require("../io/delete-file");
 const head_file_1 = require("../io/head-file");
 const list_objects_1 = require("../io/list-objects");
 const read_file_1 = require("../io/read-file");
 const write_file_1 = require("../io/write-file");
+const call_lambda_async_1 = require("../shared/call-lambda-async");
+const call_lambda_streaming_1 = require("../shared/call-lambda-streaming");
+const call_lambda_sync_1 = require("../shared/call-lambda-sync");
 const convert_to_serve_url_1 = require("../shared/convert-to-serve-url");
+const get_account_id_1 = require("../shared/get-account-id");
+const get_aws_urls_1 = require("../shared/get-aws-urls");
+const is_flaky_error_1 = require("../shared/is-flaky-error");
 const lifecycle_rules_1 = require("../shared/lifecycle-rules");
 const random_hash_1 = require("../shared/random-hash");
 const get_current_region_1 = require("./helpers/get-current-region");
 const get_folder_files_1 = require("./helpers/get-folder-files");
+const get_output_url_from_metadata_1 = require("./helpers/get-output-url-from-metadata");
 const make_aws_artifact_1 = require("./helpers/make-aws-artifact");
 if (/^AWS_Lambda_nodejs(?:18|20)[.]x$/.test((_a = process.env.AWS_EXECUTION_ENV) !== null && _a !== void 0 ? _a : '') === true) {
     process.env.FONTCONFIG_PATH = '/opt';
@@ -27,6 +39,20 @@ if (/^AWS_Lambda_nodejs(?:18|20)[.]x$/.test((_a = process.env.AWS_EXECUTION_ENV)
     // @ts-expect-error
     globalThis._dumpUnreleasedBuffers.setMaxListeners(201);
 }
+const validateDeleteAfter = (lifeCycleValue) => {
+    if (lifeCycleValue === null) {
+        return;
+    }
+    if (lifeCycleValue === undefined) {
+        return;
+    }
+    if (typeof lifeCycleValue !== 'string') {
+        throw new TypeError(`Expected life cycle value to be a string, got ${JSON.stringify(lifeCycleValue)}`);
+    }
+    if (!(lifeCycleValue in client_1.expiryDays)) {
+        throw new TypeError(`Expected deleteAfter value to be one of ${Object.keys(client_1.expiryDays).join(', ')}, got ${lifeCycleValue}`);
+    }
+};
 exports.awsImplementation = {
     getChromiumPath() {
         return '/opt/bin/chromium';
@@ -46,4 +72,24 @@ exports.awsImplementation = {
     printLoggingHelper: true,
     getFolderFiles: get_folder_files_1.getFolderFiles,
     makeArtifactWithDetails: make_aws_artifact_1.makeAwsArtifact,
+    validateDeleteAfter,
+    callFunctionAsync: call_lambda_async_1.callFunctionAsyncImplementation,
+    callFunctionStreaming: call_lambda_streaming_1.callFunctionWithStreamingImplementation,
+    callFunctionSync: call_lambda_sync_1.callFunctionSyncImplementation,
+    getEphemeralStorageForPriceCalculation() {
+        // We cannot determine the ephemeral storage size, so we
+        // overestimate the price, but will only have a miniscule effect (~0.2%)
+        return defaults_1.MAX_EPHEMERAL_STORAGE_IN_MB;
+    },
+    estimatePrice: estimate_price_1.estimatePrice,
+    getLoggingUrlForMethod: get_aws_urls_1.getCloudwatchMethodUrl,
+    getLoggingUrlForRendererFunction: get_aws_urls_1.getCloudwatchRendererUrl,
+    isFlakyError: is_flaky_error_1.isFlakyError,
+    getOutputUrl: get_output_url_from_metadata_1.getOutputUrlFromMetadata,
+    serverStorageProductName: () => 'S3',
+    getMaxStillInlinePayloadSize: () => 5000000,
+    getMaxNonInlinePayloadSizePerFunction: () => 200000,
+    getAccountId: get_account_id_1.getAccountIdImplementation,
+    deleteFunction: delete_function_1.deleteFunction,
+    getFunctions: get_functions_1.getFunctions,
 };

package/dist/functions/aws-server-implementation.d.ts

@@ -0,0 +1,2 @@
+import type { InsideFunctionSpecifics } from '@remotion/serverless';
+export declare const serverAwsImplementation: InsideFunctionSpecifics;

package/dist/functions/aws-server-implementation.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverAwsImplementation = void 0;
+const serverless_1 = require("@remotion/serverless");
+const clean_tmpdir_1 = require("./helpers/clean-tmpdir");
+const lifecycle_1 = require("./helpers/lifecycle");
+const timer_1 = require("./helpers/timer");
+exports.serverAwsImplementation = {
+    forgetBrowserEventLoop: serverless_1.forgetBrowserEventLoopImplementation,
+    getBrowserInstance: serverless_1.getBrowserInstanceImplementation,
+    timer: timer_1.timer,
+    generateRandomId: ({ deleteAfter, randomHashFn }) => {
+        return (0, lifecycle_1.generateRandomHashWithLifeCycleRule)({ deleteAfter, randomHashFn });
+    },
+    deleteTmpDir: () => Promise.resolve((0, clean_tmpdir_1.deleteTmpDir)()),
+    getCurrentFunctionName: () => {
+        if (!process.env.AWS_LAMBDA_FUNCTION_NAME) {
+            throw new Error('Expected AWS_LAMBDA_FUNCTION_NAME to be set');
+        }
+        return process.env.AWS_LAMBDA_FUNCTION_NAME;
+    },
+    getCurrentMemorySizeInMb: () => {
+        return Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE);
+    },
+};

package/dist/functions/full-client-implementation.d.ts

@@ -0,0 +1,3 @@
+import type { FullClientSpecifics } from '@remotion/serverless';
+import type { AwsProvider } from './aws-implementation';
+export declare const awsFullClientSpecifics: FullClientSpecifics<AwsProvider>;

package/dist/functions/full-client-implementation.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awsFullClientSpecifics = void 0;
+const bundler_1 = require("@remotion/bundler");
+const create_function_1 = require("../api/create-function");
+const upload_dir_1 = require("../api/upload-dir");
+const check_credentials_1 = require("../shared/check-credentials");
+const read_dir_1 = require("../shared/read-dir");
+exports.awsFullClientSpecifics = {
+    bundleSite: bundler_1.bundle,
+    id: '__remotion_full_client_specifics',
+    readDirectory: read_dir_1.readDirectory,
+    uploadDir: upload_dir_1.uploadDir,
+    createFunction: create_function_1.createFunction,
+    checkCredentials: check_credentials_1.checkCredentials,
+};

package/dist/functions/helpers/clean-tmpdir.js

@@ -29,8 +29,6 @@ const deleteAllFilesInAFolderRecursively = (path) => {
     }
 };
 const deleteTmpDir = () => {
-    if (!process.env.VITEST) {
-        deleteAllFilesInAFolderRecursively('/tmp');
-    }
+    deleteAllFilesInAFolderRecursively('/tmp');
 };
 exports.deleteTmpDir = deleteTmpDir;

package/dist/functions/helpers/get-current-region.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCurrentRegionInFunctionImplementation = void 0;
-const is_in_lambda_1 = require("../../shared/is-in-lambda");
 const getCurrentRegionInFunctionImplementation = () => {
-    if (!(0, is_in_lambda_1.isInsideLambda)()) {
-        throw new Error('Should not call getCurrentRegionInFunctionImplementation() if not inside a lambda function');
-    }
     if (!process.env.AWS_REGION) {
         throw new Error('Expected process.env.AWS_REGION to be defined');
     }

package/dist/functions/helpers/get-output-url-from-metadata.d.ts

@@ -1,7 +1,3 @@
-import type { CloudProvider } from '@remotion/serverless';
-import type { RenderMetadata } from '@remotion/serverless/client';
-import { type CustomCredentials } from '@remotion/serverless/client';
-export declare const getOutputUrlFromMetadata: <Provider extends CloudProvider>(renderMetadata: RenderMetadata<Provider>, bucketName: string, customCredentials: CustomCredentials<Provider> | null, currentRegion: Provider["region"]) => {
-    url: string;
-    key: string;
-};
+import type { GetOutputUrl } from '@remotion/serverless';
+import type { AwsProvider } from '../aws-implementation';
+export declare const getOutputUrlFromMetadata: GetOutputUrl<AwsProvider>;

package/dist/functions/helpers/get-output-url-from-metadata.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOutputUrlFromMetadata = void 0;
 const client_1 = require("@remotion/serverless/client");
-const getOutputUrlFromMetadata = (renderMetadata, bucketName, customCredentials, currentRegion) => {
+const getOutputUrlFromMetadata = ({ renderMetadata, bucketName, customCredentials, currentRegion, }) => {
     const { key, renderBucketName } = (0, client_1.getExpectedOutName)(renderMetadata, bucketName, customCredentials);
     return {
         url: `https://s3.${currentRegion}.amazonaws.com/${renderBucketName}/${key}`,

package/dist/functions/helpers/lifecycle.d.ts

@@ -2,5 +2,7 @@ import type { LifecycleRule } from '@aws-sdk/client-s3';
 import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless';
 import type { DeleteAfter } from '@remotion/serverless/client';
 export declare const getLifeCycleRules: () => LifecycleRule[];
-export declare const generateRandomHashWithLifeCycleRule: <Provider extends CloudProvider>(deleteAfter: DeleteAfter | null, providerSpecifics: ProviderSpecifics<Provider>) => string;
-export declare const validateDeleteAfter: (lifeCycleValue: unknown) => void;
+export declare const generateRandomHashWithLifeCycleRule: <Provider extends CloudProvider>({ deleteAfter, randomHashFn, }: {
+    deleteAfter: DeleteAfter | null;
+    randomHashFn: ProviderSpecifics<Provider>["randomHash"];
+}) => string;

package/dist/functions/helpers/lifecycle.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateDeleteAfter = exports.generateRandomHashWithLifeCycleRule = exports.getLifeCycleRules = void 0;
+exports.generateRandomHashWithLifeCycleRule = exports.getLifeCycleRules = void 0;
 const client_1 = require("@remotion/serverless/client");
 const getEnabledLifeCycleRule = ({ key, value, }) => {
     return {
@@ -18,22 +18,7 @@ const getLifeCycleRules = () => {
     return Object.entries(client_1.expiryDays).map(([key, value]) => getEnabledLifeCycleRule({ key, value }));
 };
 exports.getLifeCycleRules = getLifeCycleRules;
-const generateRandomHashWithLifeCycleRule = (deleteAfter, providerSpecifics) => {
-    return [deleteAfter, providerSpecifics.randomHash()].filter(client_1.truthy).join('-');
+const generateRandomHashWithLifeCycleRule = ({ deleteAfter, randomHashFn, }) => {
+    return [deleteAfter, randomHashFn()].filter(client_1.truthy).join('-');
 };
 exports.generateRandomHashWithLifeCycleRule = generateRandomHashWithLifeCycleRule;
-const validateDeleteAfter = (lifeCycleValue) => {
-    if (lifeCycleValue === null) {
-        return;
-    }
-    if (lifeCycleValue === undefined) {
-        return;
-    }
-    if (typeof lifeCycleValue !== 'string') {
-        throw new TypeError(`Expected life cycle value to be a string, got ${JSON.stringify(lifeCycleValue)}`);
-    }
-    if (!(lifeCycleValue in client_1.expiryDays)) {
-        throw new TypeError(`Expected deleteAfter value to be one of ${Object.keys(client_1.expiryDays).join(', ')}, got ${lifeCycleValue}`);
-    }
-};
-exports.validateDeleteAfter = validateDeleteAfter;

package/dist/functions/helpers/timer.d.ts

@@ -1,4 +1,2 @@
-import type { LogLevel } from '@remotion/renderer';
-export declare const timer: (label: string, logLevel: LogLevel) => {
-    end: () => void;
-};
+import type { DebuggingTimer } from '@remotion/serverless';
+export declare const timer: DebuggingTimer;

package/dist/functions/index.d.ts

@@ -1,12 +1,5 @@
-import type { CloudProvider, ProviderSpecifics, ResponseStream } from '@remotion/serverless';
+import type { RequestContext, ResponseStream } from '@remotion/serverless';
 import type { ServerlessPayload } from '@remotion/serverless/client';
 import type { AwsProvider } from './aws-implementation';
-import type { RequestContext } from './helpers/request-context';
-export type OrError<T> = T | {
-    type: 'error';
-    message: string;
-    stack: string;
-};
-export declare const innerRoutine: <Provider extends CloudProvider>(params: ServerlessPayload<Provider>, responseStream: ResponseStream, context: RequestContext, providerSpecifics: ProviderSpecifics<Provider>) => Promise<void>;
 export declare const routine: (params: ServerlessPayload<AwsProvider>, responseStream: ResponseStream, context: RequestContext) => Promise<void>;
 export declare const handler: Function;

package/dist/functions/index.js

@@ -1,244 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handler = exports.routine = exports.innerRoutine = void 0;
-const renderer_1 = require("@remotion/renderer");
+exports.handler = exports.routine = void 0;
 const serverless_1 = require("@remotion/serverless");
-const client_1 = require("@remotion/serverless/client");
-const constants_1 = require("../shared/constants");
 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_logging_helper_1 = require("./helpers/print-logging-helper");
+const aws_server_implementation_1 = require("./aws-server-implementation");
 const streamify_response_1 = require("./helpers/streamify-response");
-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 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();
-    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'AWS Request ID:', context.awsRequestId);
-    (0, leak_detection_1.stopLeakDetection)();
-    if (!(context === null || context === void 0 ? void 0 : context.invokedFunctionArn)) {
-        throw new Error('Lambda function unexpectedly does not have context.invokedFunctionArn');
-    }
-    (0, clean_tmpdir_1.deleteTmpDir)();
-    const isWarm = (0, is_warm_1.getWarm)();
-    (0, is_warm_1.setWarm)();
-    const currentUserId = context.invokedFunctionArn.split(':')[4];
-    if (params.type === client_1.ServerlessRoutines.still) {
-        (0, lifecycle_1.validateDeleteAfter)(params.deleteAfter);
-        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 = async (payload) => {
-                    if (!params.streamed) {
-                        if (payload.type !== 'still-rendered') {
-                            throw new Error('Expected still-rendered');
-                        }
-                        await responseWriter.write(Buffer.from(JSON.stringify(payload.payload)));
-                        return;
-                    }
-                    const message = (0, client_1.makeStreamPayload)({
-                        message: payload,
-                    });
-                    return new Promise((innerResolve, innerReject) => {
-                        responseWriter
-                            .write(message)
-                            .then(() => {
-                            innerResolve();
-                        })
-                            .catch((err) => {
-                            reject(err);
-                            innerReject(err);
-                        });
-                    });
-                };
-                if (params.streamed) {
-                    onStream({
-                        type: 'render-id-determined',
-                        payload: { renderId },
-                    });
-                }
-                (0, still_1.stillHandler)({
-                    expectedBucketOwner: currentUserId,
-                    params,
-                    renderId,
-                    onStream,
-                    timeoutInMilliseconds,
-                    providerSpecifics,
-                })
-                    .then((r) => {
-                    resolve(r);
-                })
-                    .catch((err) => {
-                    reject(err);
-                });
-            });
-            await responseWriter.end();
-        }
-        catch (err) {
-            console.log({ err });
-        }
-        return;
-    }
-    if (params.type === client_1.ServerlessRoutines.start) {
-        const renderId = (0, lifecycle_1.generateRandomHashWithLifeCycleRule)(params.deleteAfter, providerSpecifics);
-        if (providerSpecifics.printLoggingHelper) {
-            (0, print_logging_helper_1.printLoggingGrepHelper)(client_1.ServerlessRoutines.start, {
-                renderId,
-                inputProps: JSON.stringify(params.inputProps),
-                isWarm,
-            }, params.logLevel);
-        }
-        const response = await (0, start_1.startHandler)(params, {
-            expectedBucketOwner: currentUserId,
-            timeoutInMilliseconds,
-            renderId,
-        }, providerSpecifics);
-        await responseWriter.write(Buffer.from(JSON.stringify(response)));
-        await responseWriter.end();
-        return;
-    }
-    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 === 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 === 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,
-            }, 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,
-                    });
-                    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);
-            })
-                .catch((err) => {
-                reject(err);
-            });
-        });
-        await responseWriter.end();
-        return;
-    }
-    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 === 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 innerRoutine = async (params, responseStream, context, providerSpecifics) => {
-    const responseWriter = (0, serverless_1.streamWriter)(responseStream);
-    try {
-        await innerHandler({
-            params,
-            responseWriter,
-            context,
-            providerSpecifics,
-        });
-    }
-    catch (err) {
-        const res = {
-            type: 'error',
-            message: err.message,
-            stack: err.stack,
-        };
-        await responseWriter.write(Buffer.from(JSON.stringify(res)));
-        await responseWriter.end();
-    }
-};
-exports.innerRoutine = innerRoutine;
+const http_client_1 = require("./http-client");
 const routine = (params, responseStream, context) => {
-    return (0, exports.innerRoutine)(params, responseStream, context, aws_implementation_1.awsImplementation);
+    const responseWriter = (0, serverless_1.streamWriter)(responseStream);
+    return (0, serverless_1.innerHandler)({
+        params,
+        responseWriter,
+        context,
+        providerSpecifics: aws_implementation_1.awsImplementation,
+        insideFunctionSpecifics: aws_server_implementation_1.serverAwsImplementation,
+        webhookClient: http_client_1.getWebhookClient,
+    });
 };
 exports.routine = routine;
 exports.handler = (0, streamify_response_1.streamifyResponse)(exports.routine);