@remotion/serverless-client 4.0.364 → 4.0.366

package/src/provider-implementation.ts

@@ -1,268 +0,0 @@
-import type {LogLevel} from '@remotion/renderer';
-import type {Readable} from 'node:stream';
-import type {DownloadBehavior} from 'remotion';
-import type {CustomCredentials, Privacy, ServerlessRoutines} from './constants';
-import type {RenderMetadata} from './render-metadata';
-import type {ServerlessReturnValues} from './return-values';
-import type {OnMessage} from './streaming/streaming';
-import type {CallFunctionOptions, CloudProvider} from './types';
-
-export type ParseFunctionName = (functionName: string) => {
-	version: string;
-	memorySizeInMb: number;
-	diskSizeInMb: number;
-	timeoutInSeconds: number;
-} | null;
-
-type DeleteFile<Provider extends CloudProvider> = (params: {
-	bucketName: string;
-	key: string;
-	region: Provider['region'];
-	customCredentials: CustomCredentials<Provider> | null;
-	forcePathStyle: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-}) => Promise<void>;
-
-export type BucketWithLocation<Provider extends CloudProvider> = {
-	name: string;
-	creationDate: number;
-	region: Provider['region'];
-};
-
-type BucketExists<Provider extends CloudProvider> = (params: {
-	bucketName: string;
-	region: Provider['region'];
-	expectedBucketOwner: string | null;
-	forcePathStyle: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-}) => Promise<boolean>;
-
-type ReadFile<Provider extends CloudProvider> = (params: {
-	bucketName: string;
-	key: string;
-	region: Provider['region'];
-	expectedBucketOwner: string | null;
-	forcePathStyle: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-}) => Promise<Readable>;
-
-type GetBuckets<Provider extends CloudProvider> = (options: {
-	region: Provider['region'];
-	forceBucketName: string | null;
-	forcePathStyle: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-}) => Promise<BucketWithLocation<Provider>[]>;
-
-type CreateBucket<Provider extends CloudProvider> = (params: {
-	region: Provider['region'];
-	bucketName: string;
-	forcePathStyle: boolean;
-	skipPutAcl: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-}) => Promise<void>;
-
-type ApplyLifeCycle<Provider extends CloudProvider> = (params: {
-	enableFolderExpiry: boolean | null;
-	bucketName: string;
-	region: Provider['region'];
-	customCredentials: CustomCredentials<Provider> | null;
-	forcePathStyle: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-}) => Promise<void>;
-
-type ListObjects<Provider extends CloudProvider> = (params: {
-	bucketName: string;
-	prefix: string;
-	region: Provider['region'];
-	expectedBucketOwner: string | null;
-	forcePathStyle: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-	continuationToken?: string;
-}) => Promise<BucketObject[]>;
-
-type BucketObject = {
-	Key: string;
-	LastModified: Date;
-	ETag: string;
-	Size: number;
-};
-
-type HeadFile<Provider extends CloudProvider> = (
-	params: HeadFileInput<Provider>,
-) => Promise<HeadFileOutput>;
-
-type RandomHash = () => string;
-
-type ConvertToServeUrl<Provider extends CloudProvider> = (params: {
-	urlOrId: string;
-	region: Provider['region'];
-	bucketName: string;
-}) => string;
-
-type HeadFileOutput = {
-	LastModified?: Date | undefined;
-	ContentLength?: number | undefined;
-};
-
-export type DeleteFunctionInput<Provider extends CloudProvider> = {
-	region: Provider['region'];
-	functionName: string;
-};
-
-export type DeleteFunction<Provider extends CloudProvider> = (
-	options: DeleteFunctionInput<Provider>,
-) => Promise<void>;
-
-export type WriteFileInput<Provider extends CloudProvider> = {
-	bucketName: string;
-	key: string;
-	body: Readable | string | Uint8Array;
-	region: Provider['region'];
-	privacy: Privacy;
-	expectedBucketOwner: string | null;
-	downloadBehavior: DownloadBehavior | null;
-	customCredentials: CustomCredentials<Provider> | null;
-	forcePathStyle: boolean;
-	storageClass: Provider['storageClass'] | null;
-	requestHandler: Provider['requestHandler'] | null;
-};
-
-type WriteFile<Provider extends CloudProvider> = (
-	params: WriteFileInput<Provider>,
-) => Promise<void>;
-
-type HeadFileInput<Provider extends CloudProvider> = {
-	bucketName: string;
-	key: string;
-	region: Provider['region'];
-	customCredentials: CustomCredentials<Provider> | null;
-	forcePathStyle: boolean;
-	requestHandler: Provider['requestHandler'] | null;
-};
-
-export type CallFunctionAsync<Provider extends CloudProvider> = <
-	T extends ServerlessRoutines,
->({
-	functionName,
-	payload,
-	region,
-	timeoutInTest,
-	requestHandler,
-}: CallFunctionOptions<T, Provider>) => Promise<void>;
-
-export type CallFunctionStreaming<Provider extends CloudProvider> = <
-	T extends ServerlessRoutines,
->(
-	options: CallFunctionOptions<T, Provider> & {
-		receivedStreamingPayload: OnMessage<Provider>;
-		retriesRemaining: number;
-	},
-) => Promise<void>;
-
-export type CallFunctionSync<Provider extends CloudProvider> = <
-	T extends ServerlessRoutines,
->({
-	functionName,
-	payload,
-	region,
-	timeoutInTest,
-}: CallFunctionOptions<T, Provider>) => Promise<
-	ServerlessReturnValues<Provider>[T]
->;
-
-export type GetOutputUrl<Provider extends CloudProvider> = (options: {
-	renderMetadata: RenderMetadata<Provider>;
-	bucketName: string;
-	customCredentials: CustomCredentials<Provider> | null;
-	currentRegion: Provider['region'];
-}) => {url: string; key: string};
-
-export type EstimatePriceInput<Provider extends CloudProvider> = {
-	region: Provider['region'];
-	memorySizeInMb: number;
-	diskSizeInMb: number;
-	lambdasInvoked: number;
-	durationInMilliseconds: number;
-};
-
-export type EstimatePrice<Provider extends CloudProvider> = ({
-	region,
-	memorySizeInMb,
-	diskSizeInMb,
-	lambdasInvoked,
-	...other
-}: EstimatePriceInput<Provider>) => number;
-
-export type GetLoggingUrlForRendererFunction<Provider extends CloudProvider> =
-	(options: {
-		region: Provider['region'];
-		functionName: string;
-		rendererFunctionName: string | null;
-		renderId: string;
-		chunk: null | number;
-	}) => string;
-
-export type GetFunctionsInput<Provider extends CloudProvider> = {
-	region: Provider['region'];
-	compatibleOnly: boolean;
-	logLevel?: LogLevel;
-};
-
-export type GetLoggingUrlForMethod<Provider extends CloudProvider> = (options: {
-	region: Provider['region'];
-	functionName: string;
-	method: ServerlessRoutines;
-	rendererFunctionName: string | null;
-	renderId: string;
-}) => string;
-
-export type GetAccountId<Provider extends CloudProvider> = (options: {
-	region: Provider['region'];
-}) => Promise<string>;
-
-export type FunctionInfo = {
-	functionName: string;
-	timeoutInSeconds: number;
-	memorySizeInMb: number;
-	version: string | null;
-	diskSizeInMb: number;
-};
-
-export type GetFunctions<Provider extends CloudProvider> = (
-	params: GetFunctionsInput<Provider>,
-) => Promise<FunctionInfo[]>;
-
-export type ProviderSpecifics<Provider extends CloudProvider> = {
-	getChromiumPath: () => string | null;
-	getBuckets: GetBuckets<Provider>;
-	getBucketPrefix: () => string;
-	createBucket: CreateBucket<Provider>;
-	applyLifeCycle: ApplyLifeCycle<Provider>;
-	listObjects: ListObjects<Provider>;
-	deleteFile: DeleteFile<Provider>;
-	bucketExists: BucketExists<Provider>;
-	randomHash: RandomHash;
-	readFile: ReadFile<Provider>;
-	writeFile: WriteFile<Provider>;
-	headFile: HeadFile<Provider>;
-	convertToServeUrl: ConvertToServeUrl<Provider>;
-	printLoggingHelper: boolean;
-	validateDeleteAfter: (lifeCycleValue: unknown) => void;
-	callFunctionAsync: CallFunctionAsync<Provider>;
-	callFunctionStreaming: CallFunctionStreaming<Provider>;
-	callFunctionSync: CallFunctionSync<Provider>;
-	estimatePrice: EstimatePrice<Provider>;
-	getLoggingUrlForRendererFunction: GetLoggingUrlForRendererFunction<Provider>;
-	getLoggingUrlForMethod: GetLoggingUrlForMethod<Provider>;
-	getEphemeralStorageForPriceCalculation: () => number;
-	getOutputUrl: GetOutputUrl<Provider>;
-	isFlakyError: (err: Error) => boolean;
-	serverStorageProductName: () => string;
-	getMaxStillInlinePayloadSize: () => number;
-	getMaxNonInlinePayloadSizePerFunction: () => number;
-	getAccountId: GetAccountId<Provider>;
-	deleteFunction: DeleteFunction<Provider>;
-	getFunctions: GetFunctions<Provider>;
-	parseFunctionName: ParseFunctionName;
-	checkCredentials: () => void;
-};

package/src/render-has-audio-video.ts

@@ -1,28 +0,0 @@
-import {NoReactAPIs} from '@remotion/renderer/pure';
-import type {RenderMetadata} from './render-metadata';
-import type {CloudProvider} from './types';
-
-export const lambdaRenderHasAudioVideo = <Provider extends CloudProvider>(
-	renderMetadata: RenderMetadata<Provider>,
-): {
-	hasAudio: boolean;
-	hasVideo: boolean;
-} => {
-	if (renderMetadata.type === 'still') {
-		throw new Error('Cannot merge stills');
-	}
-
-	const support = NoReactAPIs.codecSupportsMedia(renderMetadata.codec);
-
-	const hasVideo = renderMetadata
-		? !NoReactAPIs.isAudioCodec(renderMetadata.codec)
-		: false;
-	const hasAudio = renderMetadata
-		? !renderMetadata.muted && support.audio
-		: false;
-
-	return {
-		hasAudio,
-		hasVideo,
-	};
-};

package/src/render-metadata.ts

@@ -1,61 +0,0 @@
-import type {
-	AudioCodec,
-	DeleteAfter,
-	StillImageFormat,
-	VideoImageFormat,
-} from '@remotion/renderer';
-import type {DownloadBehavior} from 'remotion';
-import type {
-	OutNameInputWithoutCredentials,
-	Privacy,
-	SerializedInputProps,
-	ServerlessCodec,
-} from './constants';
-import type {CloudProvider} from './types';
-
-type Discriminated =
-	| {
-			type: 'still';
-			imageFormat: StillImageFormat;
-			codec: null;
-	  }
-	| {
-			type: 'video';
-			imageFormat: VideoImageFormat;
-			muted: boolean;
-			frameRange: [number, number];
-			everyNthFrame: number;
-			codec: ServerlessCodec;
-	  };
-
-type Dimensions = {
-	width: number;
-	height: number;
-};
-
-export type RenderMetadata<Provider extends CloudProvider> = Discriminated & {
-	siteId: string;
-	startedDate: number;
-	totalChunks: number;
-	estimatedTotalLambdaInvokations: number;
-	estimatedRenderLambdaInvokations: number;
-	compositionId: string;
-	audioCodec: AudioCodec | null;
-	inputProps: SerializedInputProps;
-	framesPerLambda: number;
-	memorySizeInMb: number;
-	functionName: string;
-	rendererFunctionName: string;
-	lambdaVersion: string;
-	region: Provider['region'];
-	renderId: string;
-	outName: OutNameInputWithoutCredentials | undefined;
-	privacy: Privacy;
-	deleteAfter: DeleteAfter | null;
-	numberOfGifLoops: number | null;
-	audioBitrate: string | null;
-	downloadBehavior: DownloadBehavior;
-	metadata: Record<string, string> | null;
-	dimensions: Dimensions;
-	scale: number;
-};

package/src/render-progress.ts

@@ -1,58 +0,0 @@
-import type {ExpensiveChunk} from './most-expensive-chunks';
-import type {RenderMetadata} from './render-metadata';
-import type {
-	ChunkRetry,
-	CloudProvider,
-	CostsInfo,
-	ReceivedArtifact,
-} from './types';
-import type {EnhancedErrorInfo} from './write-error-to-storage';
-
-export type CleanupInfo = {
-	doneIn: number | null;
-	minFilesToDelete: number;
-	filesDeleted: number;
-};
-
-type EncodingProgress = {
-	framesEncoded: number;
-	combinedFrames: number;
-	timeToCombine: number | null;
-};
-
-export type GenericRenderProgress<Provider extends CloudProvider> = {
-	chunks: number;
-	done: boolean;
-	encodingStatus: EncodingProgress | null;
-	costs: CostsInfo;
-	renderId: string;
-	renderMetadata: RenderMetadata<Provider> | null;
-	bucket: string;
-	outputFile: string | null;
-	outKey: string | null;
-	outBucket: string | null;
-	timeToFinish: number | null;
-	errors: EnhancedErrorInfo[];
-	fatalErrorEncountered: boolean;
-	currentTime: number;
-	renderSize: number;
-	lambdasInvoked: number;
-	cleanup: CleanupInfo | null;
-	timeToFinishChunks: number | null;
-	timeToRenderFrames: number | null;
-	timeToEncode: number | null;
-	overallProgress: number;
-	retriesInfo: ChunkRetry[];
-	mostExpensiveFrameRanges: ExpensiveChunk[] | null;
-	framesRendered: number;
-	outputSizeInBytes: number | null;
-	type: 'success';
-	estimatedBillingDurationInMilliseconds: number | null;
-	combinedFrames: number;
-	timeToCombine: number | null;
-	timeoutTimestamp: number;
-	functionLaunched: number;
-	serveUrlOpened: number | null;
-	compositionValidated: number | null;
-	artifacts: ReceivedArtifact<Provider>[];
-};

package/src/return-values.ts

@@ -1,45 +0,0 @@
-import type {VideoConfig} from 'remotion/no-react';
-import type {ServerlessRoutines} from './constants';
-import type {GenericRenderProgress} from './render-progress';
-import type {CloudProvider} from './types';
-
-export type OrError<T> =
-	| T
-	| {
-			type: 'error';
-			message: string;
-			stack: string;
-	  };
-
-export interface ServerlessReturnValues<Provider extends CloudProvider> {
-	[ServerlessRoutines.start]: Promise<{
-		type: 'success';
-		bucketName: string;
-		renderId: string;
-	}>;
-	[ServerlessRoutines.launch]: Promise<{
-		type: 'success';
-	}>;
-	[ServerlessRoutines.renderer]: Promise<{
-		type: 'success';
-	}>;
-	[ServerlessRoutines.status]: Promise<GenericRenderProgress<Provider>>;
-	[ServerlessRoutines.info]: {
-		version: string;
-		type: 'success';
-	};
-	[ServerlessRoutines.still]: Promise<
-		| {
-				type: 'success';
-		  }
-		| {
-				type: 'error';
-				message: string;
-				stack: string;
-		  }
-	>;
-	[ServerlessRoutines.compositions]: Promise<{
-		compositions: VideoConfig[];
-		type: 'success';
-	}>;
-}

package/src/serialize-artifact.ts

@@ -1,66 +0,0 @@
-import type {EmittedArtifact} from '@remotion/renderer';
-import type {DownloadBehavior} from 'remotion/no-react';
-
-export type SerializedArtifact = {
-	filename: string;
-	stringContent: string;
-	frame: number;
-	binary: boolean;
-	downloadBehavior: DownloadBehavior | null;
-};
-
-export const deserializeArtifact = (
-	serializedArtifact: SerializedArtifact,
-): EmittedArtifact => {
-	if (serializedArtifact.binary) {
-		const binaryString = atob(serializedArtifact.stringContent);
-		const bytes = new Uint8Array(binaryString.length);
-		for (let i = 0; i < binaryString.length; i++) {
-			bytes[i] = binaryString.charCodeAt(i);
-		}
-
-		return {
-			filename: serializedArtifact.filename,
-			content: bytes,
-			frame: serializedArtifact.frame,
-			downloadBehavior: serializedArtifact.downloadBehavior,
-		};
-	}
-
-	return {
-		filename: serializedArtifact.filename,
-		content: serializedArtifact.stringContent,
-		frame: serializedArtifact.frame,
-		downloadBehavior: serializedArtifact.downloadBehavior,
-	};
-};
-
-export const serializeArtifact = (
-	artifact: EmittedArtifact,
-): SerializedArtifact => {
-	if (artifact.content instanceof Uint8Array) {
-		let binary = '';
-		const bytes = new Uint8Array(artifact.content);
-		const len = bytes.byteLength;
-		for (let i = 0; i < len; i++) {
-			binary += String.fromCharCode(bytes[i]);
-		}
-
-		const b64encoded = btoa(binary);
-		return {
-			filename: artifact.filename,
-			stringContent: b64encoded,
-			frame: artifact.frame,
-			binary: true,
-			downloadBehavior: artifact.downloadBehavior,
-		};
-	}
-
-	return {
-		filename: artifact.filename,
-		stringContent: artifact.content,
-		frame: artifact.frame,
-		binary: false,
-		downloadBehavior: artifact.downloadBehavior,
-	};
-};

package/src/stream-to-string.ts

@@ -1,14 +0,0 @@
-import type {Readable} from 'stream';
-
-export function streamToString(stream: Readable | Buffer) {
-	if (Buffer.isBuffer(stream)) {
-		return stream.toString('utf-8');
-	}
-
-	const chunks: Uint8Array[] = [];
-	return new Promise<string>((resolve, reject) => {
-		stream.on('data', (chunk) => chunks.push(new Uint8Array(chunk)));
-		stream.on('error', (err) => reject(err));
-		stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-	});
-}

package/src/streaming/streaming.ts

@@ -1,148 +0,0 @@
-import {makeStreamPayloadMessage} from '@remotion/streaming';
-import type {SerializedArtifact} from '../serialize-artifact';
-import type {CloudProvider, RenderStillFunctionResponsePayload} from '../types';
-import type {FunctionErrorInfo} from '../write-error-to-storage';
-
-const framesRendered = 'frames-rendered' as const;
-const errorOccurred = 'error-occurred' as const;
-const renderIdDetermined = 'render-id-determined' as const;
-const videoChunkRendered = 'video-chunk-rendered' as const;
-const audioChunkRendered = 'audio-chunk-rendered' as const;
-const chunkComplete = 'chunk-complete' as const;
-const stillRendered = 'still-rendered' as const;
-const functionInvoked = 'lambda-invoked' as const;
-const artifactEmitted = 'artifact-emitted' as const;
-
-const messageTypes = {
-	'1': {type: framesRendered},
-	'2': {type: errorOccurred},
-	'3': {type: renderIdDetermined},
-	'4': {type: videoChunkRendered},
-	'5': {type: audioChunkRendered},
-	'6': {type: stillRendered},
-	'7': {type: chunkComplete},
-	'8': {type: functionInvoked},
-	'9': {type: artifactEmitted},
-} as const;
-
-export type MessageTypeId = keyof typeof messageTypes;
-type MessageType = (typeof messageTypes)[MessageTypeId]['type'];
-
-export const formatMap: {[key in MessageType]: 'json' | 'binary'} = {
-	[framesRendered]: 'json',
-	[errorOccurred]: 'json',
-	[renderIdDetermined]: 'json',
-	[videoChunkRendered]: 'binary',
-	[audioChunkRendered]: 'binary',
-	[stillRendered]: 'json',
-	[chunkComplete]: 'json',
-	[functionInvoked]: 'json',
-	[artifactEmitted]: 'json',
-};
-
-export type StreamingPayload<Provider extends CloudProvider> =
-	| {
-			type: typeof framesRendered;
-			payload: {
-				rendered: number;
-				encoded: number;
-			};
-	  }
-	| {
-			type: typeof videoChunkRendered;
-			payload: Uint8Array;
-	  }
-	| {
-			type: typeof audioChunkRendered;
-			payload: Uint8Array;
-	  }
-	| {
-			type: typeof errorOccurred;
-			payload: {
-				error: string;
-				shouldRetry: boolean;
-				errorInfo: FunctionErrorInfo;
-			};
-	  }
-	| {
-			type: typeof renderIdDetermined;
-			payload: {
-				renderId: string;
-			};
-	  }
-	| {
-			type: typeof stillRendered;
-			payload: RenderStillFunctionResponsePayload<Provider>;
-	  }
-	| {
-			type: typeof chunkComplete;
-			payload: {
-				start: number;
-				rendered: number;
-			};
-	  }
-	| {
-			type: typeof functionInvoked;
-			payload: {
-				attempt: number;
-			};
-	  }
-	| {
-			type: typeof artifactEmitted;
-			payload: {
-				artifact: SerializedArtifact;
-			};
-	  };
-
-export const messageTypeIdToMessageType = (
-	messageTypeId: MessageTypeId,
-): MessageType => {
-	const types = messageTypes[messageTypeId];
-	if (!types) {
-		throw new Error(`Unknown message type id ${messageTypeId}`);
-	}
-
-	return types.type;
-};
-
-const messageTypeToMessageId = (messageType: MessageType): MessageTypeId => {
-	const id = (Object.keys(messageTypes) as unknown as MessageTypeId[]).find(
-		(key) => messageTypes[key].type === messageType,
-	) as MessageTypeId;
-
-	if (!id) {
-		throw new Error(`Unknown message type ${messageType}`);
-	}
-
-	return id;
-};
-
-export type StreamingMessage<Provider extends CloudProvider> = {
-	successType: 'error' | 'success';
-	message: StreamingPayload<Provider>;
-};
-
-export type OnMessage<Provider extends CloudProvider> = (
-	options: StreamingMessage<Provider>,
-) => void;
-
-export type OnStream<Provider extends CloudProvider> = (
-	payload: StreamingPayload<Provider>,
-) => Promise<void>;
-
-export const makeStreamPayload = <Provider extends CloudProvider>({
-	message,
-}: {
-	message: StreamingPayload<Provider>;
-}) => {
-	const body =
-		formatMap[message.type] === 'json'
-			? new TextEncoder().encode(JSON.stringify(message.payload))
-			: (message.payload as Uint8Array);
-
-	return makeStreamPayloadMessage({
-		body,
-		nonce: messageTypeToMessageId(message.type),
-		status: 0,
-	});
-};

package/src/test/best-frames.test.ts

@@ -1,15 +0,0 @@
-import {expect, test} from 'bun:test';
-import {bestFramesPerFunctionParam} from '../best-frames-per-function-param';
-
-test('Get reasonable framesPerFunction defaults', () => {
-	expect(bestFramesPerFunctionParam(20)).toEqual(20);
-	expect(bestFramesPerFunctionParam(21)).toEqual(11);
-	expect(bestFramesPerFunctionParam(100)).toEqual(20);
-	expect(bestFramesPerFunctionParam(2000)).toEqual(24);
-	expect(bestFramesPerFunctionParam(4000)).toEqual(44);
-	expect(bestFramesPerFunctionParam(8000)).toEqual(74);
-	expect(bestFramesPerFunctionParam(10000)).toEqual(86);
-	expect(bestFramesPerFunctionParam(14000)).toEqual(105);
-	expect(bestFramesPerFunctionParam(18000)).toEqual(120);
-	expect(bestFramesPerFunctionParam(216000)).toEqual(1440);
-});