@remotion/lambda-client 4.0.261

package/.turbo/turbo-make.log

@@ -0,0 +1,6 @@
+
+
+> @remotion/lambda-client@4.0.261 make /Users/jonathanburger/remotion/packages/lambda-client
+> tsc -d && bun --env-file=../.env.bundle bundle.ts
+
+[19.74ms] Generated.

package/LICENSE.md

@@ -0,0 +1,49 @@
+# Remotion License
+
+In Remotion 5.0, the license will slightly change. [View the changes here](https://github.com/remotion-dev/remotion/pull/3750).
+
+---
+
+Depending on the type of your legal entity, you are granted permission to use Remotion for your project. Individuals and small companies are allowed to use Remotion to create videos for free (even commercial), while a company license is required for for-profit organizations of a certain size. This two-tier system was designed to ensure funding for this project while still allowing the source code to be available and the program to be free for most. Read below for the exact terms of use.
+
+- [Free license](#free-license)
+- [Company license](#company-license)
+
+## Free license
+
+Copyright © 2025 [Remotion](https://www.remotion.dev)
+
+### Eligibility
+
+You are eligible to use Remotion for free if you are:
+
+- an individual
+- a for-profit organization with up to 3 employees
+- a non-profit or not-for-profit organization
+- evaluating whether Remotion is a good fit, and are not yet using it in a commercial way
+
+### Allowed use cases
+
+Permission is hereby granted, free of charge, to any person eligible for the "Free license", to use the software non-commercially or commercially for the purpose of creating videos and images and to modify the software to their own liking, for the purpose of fulfilling their custom use case or to contribute bug fixes or improvements back to Remotion.
+
+### Disallowed use cases
+
+It is not allowed to copy or modify Remotion code for the purpose of selling, renting, licensing, relicensing, or sublicensing your own derivate of Remotion.
+
+### Warranty notice
+
+The software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the author or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
+
+### Support
+
+Support is provided on a best-we-can-do basis via GitHub Issues and Discord.
+
+## Company license
+
+You are required to obtain a company license to use Remotion if you are not within the group of entities eligible for a free license. This license will enable you to use Remotion for the allowed use cases specified in the free license, and give you access to prioritized support (read the [Support Policy](https://www.remotion.dev/docs/support)).
+
+Visit [remotion.pro](https://www.remotion.pro/license) for pricing and to buy a license.
+
+### FAQs
+
+Are you not sure whether you need a company license because of an edge case? Here are some [frequently asked questions](https://www.remotion.pro/faq).

package/README.md

@@ -0,0 +1,5 @@
+# @remotion/lambda-client
+ 
+## Usage
+ 
+This is an internal package and has no documentation.

package/bundle.ts

@@ -0,0 +1,20 @@
+import {buildPackage} from '../.monorepo/builder';
+
+await buildPackage({
+	formats: {
+		cjs: 'use-tsc',
+		esm: 'build',
+	},
+	external: 'dependencies',
+	entrypoints: [
+		{
+			path: 'src/index.ts',
+			target: 'node',
+		},
+		{
+			path: 'src/constants.ts',
+			target: 'browser',
+		},
+		{path: 'src/regions.ts', target: 'browser'},
+	],
+});

package/dist/app-router-webhook.d.ts

@@ -0,0 +1,10 @@
+import type { WebhookErrorPayload, WebhookSuccessPayload, WebhookTimeoutPayload } from '@remotion/serverless-client';
+export type NextWebhookArgs = {
+    testing?: boolean;
+    extraHeaders?: Record<string, string>;
+    secret: string;
+    onSuccess?: (payload: WebhookSuccessPayload) => void;
+    onTimeout?: (payload: WebhookTimeoutPayload) => void;
+    onError?: (payload: WebhookErrorPayload) => void;
+};
+export declare const appRouterWebhook: (options: NextWebhookArgs) => ((req: Request) => Promise<Response>);

package/dist/app-router-webhook.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appRouterWebhook = void 0;
+const validate_webhook_signature_1 = require("./validate-webhook-signature");
+const appRouterWebhook = (options) => {
+    const { testing, extraHeaders, secret, onSuccess, onTimeout, onError } = options;
+    return async function (req) {
+        let headers = extraHeaders || {};
+        if (testing) {
+            const testingheaders = {
+                'Access-Control-Allow-Origin': 'https://www.remotion.dev',
+                'Access-Control-Allow-Headers': 'X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version, X-Remotion-Status, X-Remotion-Signature, X-Remotion-Mode',
+                'Access-Control-Allow-Methods': 'OPTIONS,POST',
+            };
+            headers = { ...headers, ...testingheaders };
+        }
+        if (req.method === 'OPTIONS') {
+            //  do we have any use of the OPTIONS method other than the tester on webhooks page ? if so we can add a condition here to only return this if testing mode enabled
+            return new Response(null, {
+                headers,
+            });
+        }
+        // Parse the body properly
+        const body = await req.json();
+        (0, validate_webhook_signature_1.validateWebhookSignature)({
+            secret,
+            body,
+            signatureHeader: req.headers.get('X-Remotion-Signature'),
+        });
+        const payload = body;
+        if (payload.type === 'success' && onSuccess) {
+            onSuccess(payload);
+        }
+        else if (payload.type === 'timeout' && onTimeout) {
+            onTimeout(payload);
+        }
+        else if (payload.type === 'error' && onError) {
+            onError(payload);
+        }
+        return new Response(JSON.stringify({ success: true }), { headers });
+    };
+};
+exports.appRouterWebhook = appRouterWebhook;

package/dist/apply-lifecycle.d.ts

@@ -0,0 +1,8 @@
+import type { DeleteBucketLifecycleCommandInput, LifecycleRule, PutBucketLifecycleConfigurationCommandInput } from '@aws-sdk/client-s3';
+export declare const deleteLifeCycleInput: ({ bucketName, }: {
+    bucketName: string;
+}) => DeleteBucketLifecycleCommandInput;
+export declare const createLifeCycleInput: ({ bucketName, lcRules, }: {
+    bucketName: string;
+    lcRules: LifecycleRule[];
+}) => PutBucketLifecycleConfigurationCommandInput;

package/dist/apply-lifecycle.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLifeCycleInput = exports.deleteLifeCycleInput = void 0;
+const deleteLifeCycleInput = ({ bucketName, }) => {
+    return {
+        Bucket: bucketName,
+    };
+};
+exports.deleteLifeCycleInput = deleteLifeCycleInput;
+const createLifeCycleInput = ({ bucketName, lcRules, }) => {
+    return {
+        Bucket: bucketName,
+        LifecycleConfiguration: {
+            Rules: lcRules,
+        },
+    };
+};
+exports.createLifeCycleInput = createLifeCycleInput;

package/dist/aws-clients.d.ts

@@ -0,0 +1,11 @@
+import type { CloudWatchLogsClient } from '@aws-sdk/client-cloudwatch-logs';
+import type { IAMClient } from '@aws-sdk/client-iam';
+import type { LambdaClient } from '@aws-sdk/client-lambda';
+import type { ServiceQuotasClient } from '@aws-sdk/client-service-quotas';
+import type { STSClient } from '@aws-sdk/client-sts';
+import type { AwsRegion } from './regions';
+export declare const getCloudWatchLogsClient: (region: AwsRegion) => CloudWatchLogsClient;
+export declare const getLambdaClient: (region: AwsRegion, _timeoutInTest?: number) => LambdaClient;
+export declare const getIamClient: (region: AwsRegion) => IAMClient;
+export declare const getServiceQuotasClient: (region: AwsRegion) => ServiceQuotasClient;
+export declare const getStsClient: (region: AwsRegion) => STSClient;

package/dist/aws-clients.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStsClient = exports.getServiceQuotasClient = exports.getIamClient = exports.getLambdaClient = exports.getCloudWatchLogsClient = void 0;
+const get_service_client_1 = require("./get-service-client");
+const getCloudWatchLogsClient = (region) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'cloudwatch',
+        customCredentials: null,
+        forcePathStyle: false,
+    });
+};
+exports.getCloudWatchLogsClient = getCloudWatchLogsClient;
+const getLambdaClient = (region, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_timeoutInTest) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'lambda',
+        customCredentials: null,
+        forcePathStyle: false,
+    });
+};
+exports.getLambdaClient = getLambdaClient;
+const getIamClient = (region) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'iam',
+        customCredentials: null,
+        forcePathStyle: false,
+    });
+};
+exports.getIamClient = getIamClient;
+const getServiceQuotasClient = (region) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'servicequotas',
+        customCredentials: null,
+        forcePathStyle: false,
+    });
+};
+exports.getServiceQuotasClient = getServiceQuotasClient;
+const getStsClient = (region) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'sts',
+        customCredentials: null,
+        forcePathStyle: false,
+    });
+};
+exports.getStsClient = getStsClient;

package/dist/aws-provider.d.ts

@@ -0,0 +1,23 @@
+import type { AwsRegion } from './regions';
+export type AwsProvider = {
+    type: 'aws';
+    region: AwsRegion;
+    receivedArtifactType: {
+        s3Key: string;
+        s3Url: string;
+    };
+    creationFunctionOptions: {
+        createCloudWatchLogGroup: boolean;
+        accountId: string;
+        alreadyCreated: boolean;
+        retentionInDays: number;
+        customRoleArn: string;
+        enableLambdaInsights: boolean;
+        vpcSubnetIds: string;
+        vpcSecurityGroupIds: string;
+        runtimePreference: RuntimePreference;
+    };
+};
+import type { ProviderSpecifics } from '@remotion/serverless-client';
+import type { RuntimePreference } from './runtime-preference';
+export declare const awsImplementation: ProviderSpecifics<AwsProvider>;

package/dist/aws-provider.js

@@ -0,0 +1,94 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.awsImplementation = void 0;
+const serverless_client_1 = require("@remotion/serverless-client");
+const node_events_1 = require("node:events");
+const bucket_exists_1 = require("./bucket-exists");
+const call_lambda_async_1 = require("./call-lambda-async");
+const call_lambda_streaming_1 = require("./call-lambda-streaming");
+const call_lambda_sync_1 = require("./call-lambda-sync");
+const check_credentials_1 = require("./check-credentials");
+const constants_1 = require("./constants");
+const convert_to_serve_url_1 = require("./convert-to-serve-url");
+const create_bucket_1 = require("./create-bucket");
+const delete_file_1 = require("./delete-file");
+const delete_function_1 = require("./delete-function");
+const estimate_price_1 = require("./estimate-price");
+const get_account_id_1 = require("./get-account-id");
+const get_aws_urls_1 = require("./get-aws-urls");
+const get_buckets_1 = require("./get-buckets");
+const get_functions_1 = require("./get-functions");
+const get_output_url_from_metadata_1 = require("./get-output-url-from-metadata");
+const head_file_1 = require("./head-file");
+const is_flaky_error_1 = require("./is-flaky-error");
+const lifecycle_rules_1 = require("./lifecycle-rules");
+const list_objects_1 = require("./list-objects");
+const parse_function_name_1 = require("./parse-function-name");
+const random_hash_1 = require("./random-hash");
+const read_file_1 = require("./read-file");
+const write_file_1 = require("./write-file");
+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';
+    process.env.FONTCONFIG_FILE = '/opt/fonts.conf';
+    process.env.DISABLE_FROM_SURFACE = '1';
+    process.env.NO_COLOR = '1';
+    // @ts-expect-error
+    globalThis._dumpUnreleasedBuffers = new node_events_1.EventEmitter();
+    // @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 serverless_client_1.expiryDays)) {
+        throw new TypeError(`Expected deleteAfter value to be one of ${Object.keys(serverless_client_1.expiryDays).join(', ')}, got ${lifeCycleValue}`);
+    }
+};
+exports.awsImplementation = {
+    getChromiumPath() {
+        return '/opt/bin/chromium';
+    },
+    getBuckets: get_buckets_1.getRemotionBuckets,
+    createBucket: create_bucket_1.createBucket,
+    applyLifeCycle: lifecycle_rules_1.applyLifeCyleOperation,
+    listObjects: list_objects_1.lambdaLsImplementation,
+    deleteFile: delete_file_1.lambdaDeleteFileImplementation,
+    bucketExists: bucket_exists_1.bucketExistsInRegionImplementation,
+    randomHash: random_hash_1.randomHashImplementation,
+    readFile: read_file_1.lambdaReadFileImplementation,
+    writeFile: write_file_1.lambdaWriteFileImplementation,
+    headFile: head_file_1.lambdaHeadFileImplementation,
+    convertToServeUrl: convert_to_serve_url_1.convertToServeUrlImplementation,
+    printLoggingHelper: true,
+    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 constants_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,
+    parseFunctionName: parse_function_name_1.parseFunctionName,
+    checkCredentials: check_credentials_1.checkCredentials,
+    getBucketPrefix: () => constants_1.REMOTION_BUCKET_PREFIX,
+};

package/dist/bucket-exists.d.ts

@@ -0,0 +1,3 @@
+import type { ProviderSpecifics } from '@remotion/serverless-client';
+import type { AwsProvider } from './aws-provider';
+export declare const bucketExistsInRegionImplementation: ProviderSpecifics<AwsProvider>['bucketExists'];

package/dist/bucket-exists.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bucketExistsInRegionImplementation = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const get_s3_client_1 = require("./get-s3-client");
+const bucketExistsInRegionImplementation = async ({ bucketName, region, expectedBucketOwner, forcePathStyle }) => {
+    var _a;
+    try {
+        const bucket = await (0, get_s3_client_1.getS3Client)({
+            region,
+            customCredentials: null,
+            forcePathStyle,
+        }).send(new client_s3_1.GetBucketLocationCommand({
+            Bucket: bucketName,
+            ExpectedBucketOwner: expectedBucketOwner !== null && expectedBucketOwner !== void 0 ? expectedBucketOwner : undefined,
+        }));
+        return ((_a = bucket.LocationConstraint) !== null && _a !== void 0 ? _a : 'us-east-1') === region;
+    }
+    catch (err) {
+        if (err.Code === 'NoSuchBucket') {
+            return false;
+        }
+        throw err;
+    }
+};
+exports.bucketExistsInRegionImplementation = bucketExistsInRegionImplementation;

package/dist/call-lambda-async.d.ts

@@ -0,0 +1,2 @@
+import type { CallFunctionOptions, CloudProvider, ServerlessRoutines } from '@remotion/serverless-client';
+export declare const callFunctionAsyncImplementation: <T extends ServerlessRoutines, Provider extends CloudProvider>({ functionName, payload, region, timeoutInTest, }: CallFunctionOptions<T, Provider>) => Promise<void>;

package/dist/call-lambda-async.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFunctionAsyncImplementation = void 0;
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const aws_clients_1 = require("./aws-clients");
+const callFunctionAsyncImplementation = async ({ functionName, payload, region, timeoutInTest, }) => {
+    const stringifiedPayload = JSON.stringify(payload);
+    if (stringifiedPayload.length > 256 * 1024) {
+        throw new Error(`Payload is too big: ${stringifiedPayload.length} bytes. Maximum size is 256 KB. This should not happen, please report this to the Remotion team. Payload: ${stringifiedPayload}`);
+    }
+    const result = await (0, aws_clients_1.getLambdaClient)(region, timeoutInTest).send(new client_lambda_1.InvokeCommand({
+        FunctionName: functionName,
+        Payload: stringifiedPayload,
+        InvocationType: 'Event',
+    }));
+    if (result.FunctionError) {
+        throw new Error(`Lambda function returned error: ${result.FunctionError} ${result.LogResult}`);
+    }
+};
+exports.callFunctionAsyncImplementation = callFunctionAsyncImplementation;

package/dist/call-lambda-streaming.d.ts

@@ -0,0 +1,6 @@
+import type { CallFunctionOptions, CloudProvider, OnMessage, ServerlessRoutines } from '@remotion/serverless-client';
+export declare const parseJsonOrThrowSource: (data: Uint8Array, type: string) => any;
+export declare const callFunctionWithStreamingImplementation: <Provider extends CloudProvider, T extends ServerlessRoutines>(options: CallFunctionOptions<T, Provider> & {
+    receivedStreamingPayload: OnMessage<Provider>;
+    retriesRemaining: number;
+}) => Promise<void>;

package/dist/call-lambda-streaming.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFunctionWithStreamingImplementation = exports.parseJsonOrThrowSource = void 0;
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const serverless_client_1 = require("@remotion/serverless-client");
+const aws_clients_1 = require("./aws-clients");
+const STREAM_STALL_TIMEOUT = 30000;
+const LAMBDA_STREAM_STALL = `AWS did not invoke Lambda in ${STREAM_STALL_TIMEOUT}ms`;
+const parseJsonOrThrowSource = (data, type) => {
+    const asString = new TextDecoder('utf-8').decode(data);
+    try {
+        return JSON.parse(asString);
+    }
+    catch (_a) {
+        throw new Error(`Invalid JSON (${type}): ${asString}`);
+    }
+};
+exports.parseJsonOrThrowSource = parseJsonOrThrowSource;
+const invokeStreamOrTimeout = async ({ region, timeoutInTest, functionName, type, payload, }) => {
+    const resProm = (0, aws_clients_1.getLambdaClient)(region, timeoutInTest).send(new client_lambda_1.InvokeWithResponseStreamCommand({
+        FunctionName: functionName,
+        Payload: JSON.stringify({ type, ...payload }),
+    }));
+    let cleanup = () => undefined;
+    const timeout = new Promise((_resolve, reject) => {
+        const int = setTimeout(() => {
+            reject(new Error(LAMBDA_STREAM_STALL));
+        }, STREAM_STALL_TIMEOUT);
+        cleanup = () => {
+            clearTimeout(int);
+        };
+    });
+    const res = await Promise.race([resProm, timeout]);
+    cleanup();
+    return res;
+};
+const INVALID_JSON_MESSAGE = 'Cannot parse Lambda response as JSON';
+const callLambdaWithStreamingWithoutRetry = async ({ functionName, type, payload, region, timeoutInTest, receivedStreamingPayload, }) => {
+    const res = await invokeStreamOrTimeout({
+        functionName,
+        payload,
+        region,
+        timeoutInTest,
+        type,
+    });
+    const { onData, clear } = (0, serverless_client_1.makeStreamer)((status, messageTypeId, data) => {
+        const messageType = (0, serverless_client_1.messageTypeIdToMessageType)(messageTypeId);
+        const innerPayload = serverless_client_1.formatMap[messageType] === 'json'
+            ? (0, exports.parseJsonOrThrowSource)(data, messageType)
+            : data;
+        const message = {
+            successType: status,
+            message: {
+                type: messageType,
+                payload: innerPayload,
+            },
+        };
+        receivedStreamingPayload(message);
+    });
+    const dumpBuffers = () => {
+        clear();
+    };
+    // @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.addListener('dump-unreleased-buffers', dumpBuffers);
+    }
+    const events = res.EventStream;
+    for await (const event of events) {
+        // There are two types of events you can get on a stream.
+        // `PayloadChunk`: These contain the actual raw bytes of the chunk
+        // It has a single property: `Payload`
+        if (event.PayloadChunk && event.PayloadChunk.Payload) {
+            onData(event.PayloadChunk.Payload);
+        }
+        if (event.InvokeComplete) {
+            if (event.InvokeComplete.ErrorCode) {
+                const logs = `https://${region}.console.aws.amazon.com/cloudwatch/home?region=${region}#logsV2:logs-insights$3FqueryDetail$3D~(end~0~start~-3600~timeType~'RELATIVE~unit~'seconds~editorString~'fields*20*40timestamp*2c*20*40requestId*2c*20*40message*0a*7c*20filter*20*40requestId*20like*20*${res.$metadata.requestId}*22*0a*7c*20sort*20*40timestamp*20asc~source~(~'*2faws*2flambda*2f${functionName}))`;
+                if (event.InvokeComplete.ErrorCode === 'Unhandled') {
+                    throw new Error(`Lambda function ${functionName} failed with an unhandled error: ${event.InvokeComplete.ErrorDetails} See ${logs} to see the logs of this invocation.`);
+                }
+                throw new Error(`Lambda function ${functionName} failed with error code ${event.InvokeComplete.ErrorCode}: ${event.InvokeComplete.ErrorDetails}. See ${logs} to see the logs of this invocation.`);
+            }
+        }
+        // Don't put a `break` statement here, as it will cause the socket to not properly exit.
+    }
+    // @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.removeListener('dump-unreleased-buffers', dumpBuffers);
+    }
+    clear();
+};
+const callFunctionWithStreamingImplementation = async (options) => {
+    // As of August 2023, Lambda streaming sometimes misses parts of the JSON response.
+    // Handling this for now by applying a retry mechanism.
+    var _a;
+    try {
+        // Do not remove this await
+        await callLambdaWithStreamingWithoutRetry(options);
+    }
+    catch (err) {
+        if ((_a = err.stack) === null || _a === void 0 ? void 0 : _a.includes('TooManyRequestsException')) {
+            throw new Error(`AWS Concurrency limit reached (Original Error: ${err.message}). See https://www.remotion.dev/docs/lambda/troubleshooting/rate-limit for tips to fix this.`);
+        }
+        if (!err.message.includes(INVALID_JSON_MESSAGE) &&
+            !err.message.includes(LAMBDA_STREAM_STALL) &&
+            // https://discord.com/channels/809501355504959528/1332166561242288220/1332166561242288220
+            !err.message.includes('Runtime.TruncatedResponse') &&
+            !err.message.includes('aborted')) {
+            throw err;
+        }
+        console.error('Retries remaining:', options.retriesRemaining);
+        if (options.retriesRemaining === 0) {
+            console.error('Throwing error:');
+            throw err;
+        }
+        console.error(err);
+        return (0, exports.callFunctionWithStreamingImplementation)({
+            ...options,
+            retriesRemaining: options.retriesRemaining - 1,
+        });
+    }
+};
+exports.callFunctionWithStreamingImplementation = callFunctionWithStreamingImplementation;

package/dist/call-lambda-sync.d.ts

@@ -0,0 +1,2 @@
+import type { CallFunctionOptions, CloudProvider, ServerlessReturnValues, ServerlessRoutines } from '@remotion/serverless-client';
+export declare const callFunctionSyncImplementation: <Provider extends CloudProvider, T extends ServerlessRoutines>(options: CallFunctionOptions<T, Provider>) => Promise<ServerlessReturnValues<Provider>[T]>;

package/dist/call-lambda-sync.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFunctionSyncImplementation = void 0;
+const client_lambda_1 = require("@aws-sdk/client-lambda");
+const aws_clients_1 = require("./aws-clients");
+const callLambdaSyncWithoutRetry = async ({ functionName, payload, region, timeoutInTest, }) => {
+    const Payload = JSON.stringify(payload);
+    const res = await (0, aws_clients_1.getLambdaClient)(region, timeoutInTest).send(new client_lambda_1.InvokeCommand({
+        FunctionName: functionName,
+        Payload,
+        InvocationType: 'RequestResponse',
+    }));
+    const decoded = new TextDecoder('utf-8').decode(res.Payload);
+    try {
+        return JSON.parse(decoded);
+    }
+    catch (_a) {
+        throw new Error(`Invalid JSON: ${JSON.stringify(decoded)}`);
+    }
+};
+const callFunctionSyncImplementation = async (options) => {
+    const res = await callLambdaSyncWithoutRetry(options);
+    if (res.type === 'error') {
+        const err = new Error(res.message);
+        err.stack = res.stack;
+        throw err;
+    }
+    return res;
+};
+exports.callFunctionSyncImplementation = callFunctionSyncImplementation;

package/dist/check-credentials.d.ts

@@ -0,0 +1 @@
+export declare const checkCredentials: () => void;

package/dist/check-credentials.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkCredentials = void 0;
+const serverless_client_1 = require("@remotion/serverless-client");
+const get_env_variable_1 = require("./get-env-variable");
+const is_cli_1 = require("./is-cli");
+const is_likely_to_have_aws_profile_1 = require("./is-likely-to-have-aws-profile");
+const messageForVariable = (variable) => {
+    return [
+        `You have tried to call a Remotion Lambda function, but have not set the environment variable ${variable}.`,
+        (0, is_cli_1.getIsCli)()
+            ? null
+            : `- Environment variables from a '.env' file are not automatically read if you are calling the Node.JS APIs, in that case you need to load the file yourself or set the environment variables manually.`,
+        `- Please refer to the Remotion Lambda docs (${serverless_client_1.DOCS_URL}/docs/lambda/setup) to see how to generate the credentials for your AWS account and then set the environment variables.`,
+        `- For more reasons see the troubleshooting page: ${serverless_client_1.DOCS_URL}/docs/lambda/troubleshooting/permissions`,
+    ]
+        .filter(serverless_client_1.truthy)
+        .join('\n');
+};
+const checkCredentials = () => {
+    if ((0, get_env_variable_1.getEnvVariable)('REMOTION_SKIP_AWS_CREDENTIALS_CHECK')) {
+        return;
+    }
+    if ((0, get_env_variable_1.getEnvVariable)('REMOTION_AWS_PROFILE') || (0, get_env_variable_1.getEnvVariable)('AWS_PROFILE')) {
+        return;
+    }
+    if ((0, is_likely_to_have_aws_profile_1.isLikelyToHaveAwsProfile)()) {
+        return;
+    }
+    if (!(0, get_env_variable_1.getEnvVariable)('AWS_ACCESS_KEY_ID') &&
+        !(0, get_env_variable_1.getEnvVariable)('REMOTION_AWS_ACCESS_KEY_ID')) {
+        throw new Error(messageForVariable('AWS_ACCESS_KEY_ID or REMOTION_AWS_ACCESS_KEY_ID'));
+    }
+    if (!(0, get_env_variable_1.getEnvVariable)('AWS_SECRET_ACCESS_KEY') &&
+        !(0, get_env_variable_1.getEnvVariable)('REMOTION_AWS_SECRET_ACCESS_KEY')) {
+        throw new Error(messageForVariable('AWS_SECRET_ACCESS_KEY or REMOTION_AWS_SECRET_ACCESS_KEY'));
+    }
+};
+exports.checkCredentials = checkCredentials;

package/dist/clean-items.d.ts

@@ -0,0 +1,16 @@
+import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless-client';
+export declare const cleanItems: <Provider extends CloudProvider>({ bucket, onAfterItemDeleted, onBeforeItemDeleted, region, list, providerSpecifics, forcePathStyle, }: {
+    bucket: string;
+    region: Provider["region"];
+    list: string[];
+    onBeforeItemDeleted: (data: {
+        bucketName: string;
+        itemName: string;
+    }) => void;
+    onAfterItemDeleted: (data: {
+        bucketName: string;
+        itemName: string;
+    }) => void;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    forcePathStyle: boolean;
+}) => Promise<void[]>;