@remotion/lambda-client 4.0.261

package/dist/validate-bucketname.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBucketName = void 0;
+const constants_1 = require("./constants");
+const regions_1 = require("./regions");
+const parseBucketName = (name) => {
+    const parsed = name.match(new RegExp(`^${constants_1.REMOTION_BUCKET_PREFIX}(.*)-([a-z0-9A-Z]+)$`));
+    const region = parsed === null || parsed === void 0 ? void 0 : parsed[1];
+    if (!region) {
+        return { region: null };
+    }
+    const realRegionFound = regions_1.AWS_REGIONS.find((r) => r.replace(/-/g, '') === region);
+    return { region: realRegionFound !== null && realRegionFound !== void 0 ? realRegionFound : null };
+};
+exports.parseBucketName = parseBucketName;

package/dist/validate-disk-size-in-mb.d.ts

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

package/dist/validate-disk-size-in-mb.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDiskSizeInMb = void 0;
+const constants_1 = require("./constants");
+const validateDiskSizeInMb = (diskSizeInMb) => {
+    if (typeof diskSizeInMb !== 'number') {
+        throw new TypeError(`parameter 'diskSizeInMb' must be a number, got a ${typeof diskSizeInMb}`);
+    }
+    if (Number.isNaN(diskSizeInMb)) {
+        throw new TypeError(`parameter 'diskSizeInMb' must not be NaN, but is`);
+    }
+    if (!Number.isFinite(diskSizeInMb)) {
+        throw new TypeError(`parameter 'diskSizeInMb' must be finite, but is ${diskSizeInMb}`);
+    }
+    if (diskSizeInMb < constants_1.MIN_EPHEMERAL_STORAGE_IN_MB ||
+        diskSizeInMb > constants_1.MAX_EPHEMERAL_STORAGE_IN_MB) {
+        throw new TypeError(`parameter 'diskSizeInMb' must be between ${constants_1.MIN_EPHEMERAL_STORAGE_IN_MB} and ${constants_1.MAX_EPHEMERAL_STORAGE_IN_MB}, but got ${diskSizeInMb}`);
+    }
+    if (diskSizeInMb % 1 !== 0) {
+        throw new TypeError(`parameter 'diskSizeInMb' must be an integer but got ${diskSizeInMb}`);
+    }
+};
+exports.validateDiskSizeInMb = validateDiskSizeInMb;

package/dist/validate-lambda-codec.d.ts

@@ -0,0 +1,2 @@
+import type { ServerlessCodec } from '@remotion/serverless-client';
+export declare const validateLambdaCodec: (codec: unknown) => ServerlessCodec;

package/dist/validate-lambda-codec.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLambdaCodec = void 0;
+const serverless_client_1 = require("@remotion/serverless-client");
+const validateLambdaCodec = (codec) => {
+    if (typeof codec !== 'string') {
+        throw new TypeError('"codec" must be a string ');
+    }
+    if (!serverless_client_1.serverlessCodecs.includes(codec)) {
+        throw new TypeError("'" +
+            codec +
+            "' is not a valid codec for Lambda. The following values are supported: " +
+            serverless_client_1.serverlessCodecs.join(', '));
+    }
+    if (codec === 'h264-mkv') {
+        console.warn('The "h264-mkv" codec for renderMediaOnLambda() is deprecated - it\'s now just "h264".');
+        return 'h264';
+    }
+    return codec;
+};
+exports.validateLambdaCodec = validateLambdaCodec;

package/dist/validate-memory-size.d.ts

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

package/dist/validate-memory-size.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMemorySize = void 0;
+const constants_1 = require("./constants");
+const validateMemorySize = (memorySizeInMb) => {
+    if (typeof memorySizeInMb !== 'number') {
+        throw new TypeError(`parameter 'memorySizeInMb' must be a number, got a ${typeof memorySizeInMb}`);
+    }
+    if (Number.isNaN(memorySizeInMb)) {
+        throw new TypeError(`parameter 'memorySizeInMb' must not be NaN, but is`);
+    }
+    if (!Number.isFinite(memorySizeInMb)) {
+        throw new TypeError(`parameter 'memorySizeInMb' must be finite, but is ${memorySizeInMb}`);
+    }
+    if (memorySizeInMb < constants_1.MIN_MEMORY || memorySizeInMb > constants_1.MAX_MEMORY) {
+        throw new TypeError(`parameter 'memorySizeInMb' must be between ${constants_1.MIN_MEMORY} and ${constants_1.MAX_MEMORY}, but got ${memorySizeInMb}`);
+    }
+    if (memorySizeInMb % 1 !== 0) {
+        throw new TypeError(`parameter 'memorySizeInMb' must be an integer but got ${memorySizeInMb}`);
+    }
+};
+exports.validateMemorySize = validateMemorySize;

package/dist/validate-presign-expiration.d.ts

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

package/dist/validate-presign-expiration.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePresignExpiration = void 0;
+const MAX_PRESIGN_EXPIRATION = 604800;
+const MIN_PRESIGN_EXPIRATION = 1;
+const validatePresignExpiration = (presignExpiration) => {
+    if (typeof presignExpiration === 'undefined' || presignExpiration === null) {
+        return;
+    }
+    if (typeof presignExpiration !== 'number') {
+        throw new TypeError(`'expiresIn' should be a number, but is ${JSON.stringify(presignExpiration)}`);
+    }
+    if (Number.isNaN(presignExpiration)) {
+        throw new TypeError(`'expiresIn' should not be NaN, but is NaN`);
+    }
+    if (!Number.isFinite(presignExpiration)) {
+        throw new TypeError(`'expiresIn' should be finite but is ${presignExpiration}`);
+    }
+    if (presignExpiration % 1 !== 0) {
+        throw new TypeError(`'expiresIn' should be an integer but is ${JSON.stringify(presignExpiration)}`);
+    }
+    if (presignExpiration > MAX_PRESIGN_EXPIRATION) {
+        throw new TypeError(`The 'expiresIn' parameter must be less or equal than ${MAX_PRESIGN_EXPIRATION} (7 days) as enforced by AWS`);
+    }
+    if (presignExpiration < MIN_PRESIGN_EXPIRATION) {
+        throw new TypeError(`The 'expiresIn' parameter must be greater or equal than ${MIN_PRESIGN_EXPIRATION}`);
+    }
+};
+exports.validatePresignExpiration = validatePresignExpiration;

package/dist/validate-serveurl.d.ts

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

package/dist/validate-serveurl.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateServeUrl = void 0;
+const validateServeUrl = (serveUrl) => {
+    if (typeof serveUrl !== 'string') {
+        throw new TypeError(`"serveURL" parameter must be a string, but is ${JSON.stringify(serveUrl)}`);
+    }
+};
+exports.validateServeUrl = validateServeUrl;

package/dist/validate-webhook-signature.d.ts

@@ -0,0 +1,5 @@
+export declare const validateWebhookSignature: ({ secret, body, signatureHeader, }: {
+    secret: string;
+    body: unknown;
+    signatureHeader: string;
+}) => void;

package/dist/validate-webhook-signature.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWebhookSignature = void 0;
+/*
+ * @description Validates that the signature received by a webhook endpoint is authentic. If validation fails, an error is thrown.
+ * @see [Documentation](https://remotion.dev/docs/lambda/validatewebhooksignature)
+ */
+const validateWebhookSignature = ({ secret, body, signatureHeader, }) => {
+    if (!secret) {
+        throw new TypeError("No 'secret' was provided to validateWebhookSignature().");
+    }
+    if (!body) {
+        throw new TypeError("No 'body' was provided to validateWebhookSignature().");
+    }
+    if (typeof require === 'undefined') {
+        throw new Error('validateWebhookSignature can only be called from Node.JS');
+    }
+    const Crypto = require('crypto');
+    const hmac = Crypto.createHmac('sha512', secret);
+    const signature = `sha512=${hmac.update(JSON.stringify(body)).digest('hex')}`;
+    if (!signatureHeader || signatureHeader === 'NO_SECRET_PROVIDED') {
+        throw new Error('No webhook signature was provided');
+    }
+    if (signatureHeader !== signature) {
+        throw new Error('Signatures do not match');
+    }
+};
+exports.validateWebhookSignature = validateWebhookSignature;

package/dist/write-file.d.ts

@@ -0,0 +1,5 @@
+import type { WriteFileInput } from '@remotion/serverless-client';
+import type { AwsProvider } from './aws-provider';
+export declare const lambdaWriteFileImplementation: (params: WriteFileInput<AwsProvider> & {
+    retries?: number;
+}) => Promise<void>;

package/dist/write-file.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lambdaWriteFileImplementation = void 0;
+/* eslint-disable no-console */
+const client_s3_1 = require("@aws-sdk/client-s3");
+const mime_types_1 = __importDefault(require("mime-types"));
+const content_disposition_header_1 = require("./content-disposition-header");
+const get_s3_client_1 = require("./get-s3-client");
+const tryLambdaWriteFile = async ({ bucketName, key, body, region, privacy, expectedBucketOwner, downloadBehavior, customCredentials, forcePathStyle, }) => {
+    await (0, get_s3_client_1.getS3Client)({
+        region,
+        customCredentials: customCredentials,
+        forcePathStyle,
+    }).send(new client_s3_1.PutObjectCommand({
+        Bucket: bucketName,
+        Key: key,
+        Body: body,
+        ACL: privacy === 'no-acl'
+            ? undefined
+            : privacy === 'private'
+                ? 'private'
+                : 'public-read',
+        ExpectedBucketOwner: customCredentials
+            ? undefined
+            : (expectedBucketOwner !== null && expectedBucketOwner !== void 0 ? expectedBucketOwner : undefined),
+        ContentType: mime_types_1.default.lookup(key) || 'application/octet-stream',
+        ContentDisposition: (0, content_disposition_header_1.getContentDispositionHeader)(downloadBehavior),
+    }));
+};
+const lambdaWriteFileImplementation = async (params) => {
+    var _a;
+    const remainingRetries = (_a = params.retries) !== null && _a !== void 0 ? _a : 2;
+    try {
+        await tryLambdaWriteFile(params);
+    }
+    catch (err) {
+        if (remainingRetries === 0) {
+            throw err;
+        }
+        const backoff = 2 ** (2 - remainingRetries) * 2000;
+        await new Promise((resolve) => {
+            setTimeout(resolve, backoff);
+        });
+        console.warn('Failed to write file to storage:');
+        console.warn(err);
+        console.warn(`Retrying (${remainingRetries} retries remaining)...`);
+        return (0, exports.lambdaWriteFileImplementation)({
+            ...params,
+            retries: remainingRetries - 1,
+        });
+    }
+};
+exports.lambdaWriteFileImplementation = lambdaWriteFileImplementation;

package/eslint.config.mjs

@@ -0,0 +1,5 @@
+import {remotionFlatConfig} from '@remotion/eslint-config-internal';
+
+const config = remotionFlatConfig({react: false});
+
+export default [config];

package/package.json

@@ -0,0 +1,71 @@
+{
+  "repository": {
+    "url": "https://github.com/remotion-dev/remotion/tree/main/packages/lambda-client"
+  },
+  "name": "@remotion/lambda-client",
+  "version": "4.0.261",
+  "main": "dist/index.js",
+  "sideEffects": false,
+  "author": "Jonny Burger <jonny@remotion.dev>",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "@aws-sdk/client-cloudwatch-logs": "3.738.0",
+    "@aws-sdk/client-iam": "3.738.0",
+    "@aws-sdk/client-lambda": "3.738.0",
+    "@aws-sdk/s3-request-presigner": "3.738.0",
+    "@aws-sdk/client-s3": "3.738.0",
+    "@aws-sdk/client-service-quotas": "3.738.0",
+    "@aws-sdk/client-sts": "3.738.0",
+    "@aws-sdk/credential-providers": "3.738.0",
+    "mime-types": "2.1.34"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "express": "4.21.0",
+    "eslint": "9.19.0",
+    "next": "15.1.6",
+    "@types/mime-types": "2.1.1",
+    "@remotion/serverless-client": "4.0.261",
+    "@remotion/eslint-config-internal": "4.0.261"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "module": "./dist/esm/index.mjs",
+      "import": "./dist/esm/index.mjs"
+    },
+    "./constants": {
+      "types": "./dist/constants.d.ts",
+      "require": "./dist/constants.js",
+      "module": "./dist/esm/constants.mjs",
+      "import": "./dist/esm/constants.mjs"
+    },
+    "./regions": {
+      "types": "./dist/regions.d.ts",
+      "require": "./dist/regions.js",
+      "module": "./dist/esm/regions.mjs",
+      "import": "./dist/esm/regions.mjs"
+    }
+  },
+  "typesVersions": {
+    ">=1.0": {
+      "constants": [
+        "dist/constants.d.ts"
+      ],
+      "regions": [
+        "dist/regions.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "formatting": "prettier src --check",
+    "test": "bun test src",
+    "lint": "eslint src",
+    "make": "tsc -d && bun --env-file=../.env.bundle bundle.ts"
+  }
+}

package/src/app-router-webhook.ts

@@ -0,0 +1,64 @@
+import type {
+	WebhookErrorPayload,
+	WebhookPayload,
+	WebhookSuccessPayload,
+	WebhookTimeoutPayload,
+} from '@remotion/serverless-client';
+import {validateWebhookSignature} from './validate-webhook-signature';
+
+export type NextWebhookArgs = {
+	testing?: boolean;
+	extraHeaders?: Record<string, string>;
+	secret: string;
+	onSuccess?: (payload: WebhookSuccessPayload) => void;
+	onTimeout?: (payload: WebhookTimeoutPayload) => void;
+	onError?: (payload: WebhookErrorPayload) => void;
+};
+
+export const appRouterWebhook = (
+	options: NextWebhookArgs,
+): ((req: Request) => Promise<Response>) => {
+	const {testing, extraHeaders, secret, onSuccess, onTimeout, onError} =
+		options;
+	return async function (req: Request): Promise<Response> {
+		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();
+
+		validateWebhookSignature({
+			secret,
+			body,
+			signatureHeader: req.headers.get('X-Remotion-Signature') as string,
+		});
+
+		const payload = body as WebhookPayload;
+
+		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});
+	};
+};

package/src/apply-lifecycle.ts

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

package/src/aws-clients.ts

@@ -0,0 +1,60 @@
+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 {getServiceClient} from './get-service-client';
+import type {AwsRegion} from './regions';
+
+export const getCloudWatchLogsClient = (
+	region: AwsRegion,
+): CloudWatchLogsClient => {
+	return getServiceClient({
+		region,
+		service: 'cloudwatch',
+		customCredentials: null,
+		forcePathStyle: false,
+	});
+};
+
+export const getLambdaClient = (
+	region: AwsRegion,
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	_timeoutInTest?: number,
+): LambdaClient => {
+	return getServiceClient({
+		region,
+		service: 'lambda',
+		customCredentials: null,
+		forcePathStyle: false,
+	});
+};
+
+export const getIamClient = (region: AwsRegion): IAMClient => {
+	return getServiceClient({
+		region,
+		service: 'iam',
+		customCredentials: null,
+		forcePathStyle: false,
+	});
+};
+
+export const getServiceQuotasClient = (
+	region: AwsRegion,
+): ServiceQuotasClient => {
+	return getServiceClient({
+		region,
+		service: 'servicequotas',
+		customCredentials: null,
+		forcePathStyle: false,
+	});
+};
+
+export const getStsClient = (region: AwsRegion): STSClient => {
+	return getServiceClient({
+		region,
+		service: 'sts',
+		customCredentials: null,
+		forcePathStyle: false,
+	});
+};

package/src/aws-provider.ts

@@ -0,0 +1,135 @@
+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 {expiryDays} from '@remotion/serverless-client';
+import {EventEmitter} from 'node:events';
+import {bucketExistsInRegionImplementation} from './bucket-exists';
+import {callFunctionAsyncImplementation} from './call-lambda-async';
+import {callFunctionWithStreamingImplementation} from './call-lambda-streaming';
+import {callFunctionSyncImplementation} from './call-lambda-sync';
+import {checkCredentials} from './check-credentials';
+import {MAX_EPHEMERAL_STORAGE_IN_MB, REMOTION_BUCKET_PREFIX} from './constants';
+import {convertToServeUrlImplementation} from './convert-to-serve-url';
+import {createBucket} from './create-bucket';
+import {lambdaDeleteFileImplementation} from './delete-file';
+import {deleteFunction} from './delete-function';
+import {estimatePrice} from './estimate-price';
+import {getAccountIdImplementation} from './get-account-id';
+import {getCloudwatchMethodUrl, getCloudwatchRendererUrl} from './get-aws-urls';
+import {getRemotionBuckets} from './get-buckets';
+import {getFunctions} from './get-functions';
+import {getOutputUrlFromMetadata} from './get-output-url-from-metadata';
+import {lambdaHeadFileImplementation} from './head-file';
+import {isFlakyError} from './is-flaky-error';
+import {applyLifeCyleOperation} from './lifecycle-rules';
+import {lambdaLsImplementation} from './list-objects';
+import {parseFunctionName} from './parse-function-name';
+import {randomHashImplementation} from './random-hash';
+import {lambdaReadFileImplementation} from './read-file';
+import type {RuntimePreference} from './runtime-preference';
+import {lambdaWriteFileImplementation} from './write-file';
+
+if (
+	/^AWS_Lambda_nodejs(?:18|20)[.]x$/.test(
+		process.env.AWS_EXECUTION_ENV ?? '',
+	) === 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 EventEmitter();
+
+	// @ts-expect-error
+	(globalThis._dumpUnreleasedBuffers as EventEmitter).setMaxListeners(201);
+}
+
+const validateDeleteAfter = (lifeCycleValue: unknown) => {
+	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 expiryDays)) {
+		throw new TypeError(
+			`Expected deleteAfter value to be one of ${Object.keys(expiryDays).join(
+				', ',
+			)}, got ${lifeCycleValue}`,
+		);
+	}
+};
+
+export const awsImplementation: ProviderSpecifics<AwsProvider> = {
+	getChromiumPath() {
+		return '/opt/bin/chromium';
+	},
+	getBuckets: getRemotionBuckets,
+	createBucket,
+	applyLifeCycle: applyLifeCyleOperation,
+	listObjects: lambdaLsImplementation,
+	deleteFile: lambdaDeleteFileImplementation,
+	bucketExists: bucketExistsInRegionImplementation,
+	randomHash: randomHashImplementation,
+	readFile: lambdaReadFileImplementation,
+	writeFile: lambdaWriteFileImplementation,
+	headFile: lambdaHeadFileImplementation,
+	convertToServeUrl: convertToServeUrlImplementation,
+	printLoggingHelper: true,
+	validateDeleteAfter,
+	callFunctionAsync: callFunctionAsyncImplementation,
+	callFunctionStreaming: callFunctionWithStreamingImplementation,
+	callFunctionSync: callFunctionSyncImplementation,
+	getEphemeralStorageForPriceCalculation() {
+		// We cannot determine the ephemeral storage size, so we
+		// overestimate the price, but will only have a miniscule effect (~0.2%)
+		return MAX_EPHEMERAL_STORAGE_IN_MB;
+	},
+	estimatePrice,
+	getLoggingUrlForMethod: getCloudwatchMethodUrl,
+	getLoggingUrlForRendererFunction: getCloudwatchRendererUrl,
+	isFlakyError,
+	getOutputUrl: getOutputUrlFromMetadata,
+	serverStorageProductName: () => 'S3',
+	getMaxStillInlinePayloadSize: () => 5_000_000,
+	getMaxNonInlinePayloadSizePerFunction: () => 200_000,
+	getAccountId: getAccountIdImplementation,
+	deleteFunction,
+	getFunctions,
+	parseFunctionName,
+	checkCredentials,
+	getBucketPrefix: () => REMOTION_BUCKET_PREFIX,
+};

package/src/bucket-exists.ts

@@ -0,0 +1,28 @@
+import {GetBucketLocationCommand} from '@aws-sdk/client-s3';
+import type {ProviderSpecifics} from '@remotion/serverless-client';
+import type {AwsProvider} from './aws-provider';
+import {getS3Client} from './get-s3-client';
+
+export const bucketExistsInRegionImplementation: ProviderSpecifics<AwsProvider>['bucketExists'] =
+	async ({bucketName, region, expectedBucketOwner, forcePathStyle}) => {
+		try {
+			const bucket = await getS3Client({
+				region,
+				customCredentials: null,
+				forcePathStyle,
+			}).send(
+				new GetBucketLocationCommand({
+					Bucket: bucketName,
+					ExpectedBucketOwner: expectedBucketOwner ?? undefined,
+				}),
+			);
+
+			return (bucket.LocationConstraint ?? 'us-east-1') === region;
+		} catch (err) {
+			if ((err as {Code: string}).Code === 'NoSuchBucket') {
+				return false;
+			}
+
+			throw err;
+		}
+	};