@remotion/lambda-client 4.0.390 → 4.0.392

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,12 @@
+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';
+import type { RequestHandler } from './types';
+export declare const getCloudWatchLogsClient: (region: AwsRegion, requestHandler: RequestHandler | null) => CloudWatchLogsClient;
+export declare const getLambdaClient: (region: AwsRegion, _timeoutInTest: number | undefined, requestHandler: RequestHandler | null) => LambdaClient;
+export declare const getIamClient: (region: AwsRegion, requestHandler: RequestHandler | null) => IAMClient;
+export declare const getServiceQuotasClient: (region: AwsRegion, requestHandler: RequestHandler | null) => ServiceQuotasClient;
+export declare const getStsClient: (region: AwsRegion, requestHandler: RequestHandler | null) => STSClient;

package/dist/aws-clients.js

@@ -0,0 +1,56 @@
+"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, requestHandler) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'cloudwatch',
+        customCredentials: null,
+        forcePathStyle: false,
+        requestHandler,
+    });
+};
+exports.getCloudWatchLogsClient = getCloudWatchLogsClient;
+const getLambdaClient = (region, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_timeoutInTest, requestHandler) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'lambda',
+        customCredentials: null,
+        forcePathStyle: false,
+        requestHandler,
+    });
+};
+exports.getLambdaClient = getLambdaClient;
+const getIamClient = (region, requestHandler) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'iam',
+        customCredentials: null,
+        forcePathStyle: false,
+        requestHandler,
+    });
+};
+exports.getIamClient = getIamClient;
+const getServiceQuotasClient = (region, requestHandler) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'servicequotas',
+        customCredentials: null,
+        forcePathStyle: false,
+        requestHandler,
+    });
+};
+exports.getServiceQuotasClient = getServiceQuotasClient;
+const getStsClient = (region, requestHandler) => {
+    return (0, get_service_client_1.getServiceClient)({
+        region,
+        service: 'sts',
+        customCredentials: null,
+        forcePathStyle: false,
+        requestHandler,
+    });
+};
+exports.getStsClient = getStsClient;

package/dist/aws-provider.d.ts

@@ -0,0 +1,27 @@
+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;
+    };
+    storageClass: StorageClass;
+    requestHandler: RequestHandler | null | undefined;
+};
+import type { StorageClass } from '@aws-sdk/client-s3';
+import type { ProviderSpecifics } from '@remotion/serverless-client';
+import type { RuntimePreference } from './runtime-preference';
+import type { RequestHandler } from './types';
+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,27 @@
+"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, requestHandler, }) => {
+    var _a;
+    try {
+        const bucket = await (0, get_s3_client_1.getS3Client)({
+            region,
+            customCredentials: null,
+            forcePathStyle,
+            requestHandler,
+        }).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, null).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,126 @@
+"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, null).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, _b;
+    try {
+        // Do not remove this await
+        await callLambdaWithStreamingWithoutRetry(options);
+    }
+    catch (err) {
+        if (((_a = err.stack) === null || _a === void 0 ? void 0 : _a.includes('TooManyRequestsException')) ||
+            ((_b = err.message) === null || _b === void 0 ? void 0 : _b.includes('ConcurrentInvocationLimitExceeded'))) {
+            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, null).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;