@remotion/serverless-client 4.0.261

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,60 @@
+import type {
+	AudioCodec,
+	DeleteAfter,
+	StillImageFormat,
+	VideoImageFormat,
+} from '@remotion/renderer';
+import type {
+	DownloadBehavior,
+	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;
+};

package/src/render-progress.ts

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,51 @@
+import type {EmittedArtifact} from '@remotion/renderer';
+
+export type SerializedArtifact = {
+	filename: string;
+	stringContent: string;
+	frame: number;
+	binary: boolean;
+};
+
+export const deserializeArtifact = (
+	serializedArtifact: SerializedArtifact,
+): EmittedArtifact => {
+	if (serializedArtifact.binary) {
+		const content = new TextEncoder().encode(
+			atob(serializedArtifact.stringContent),
+		);
+
+		return {
+			filename: serializedArtifact.filename,
+			content,
+			frame: serializedArtifact.frame,
+		};
+	}
+
+	return {
+		filename: serializedArtifact.filename,
+		content: serializedArtifact.stringContent,
+		frame: serializedArtifact.frame,
+	};
+};
+
+export const serializeArtifact = (
+	artifact: EmittedArtifact,
+): SerializedArtifact => {
+	if (artifact.content instanceof Uint8Array) {
+		const b64encoded = btoa(new TextDecoder('utf8').decode(artifact.content));
+		return {
+			filename: artifact.filename,
+			stringContent: b64encoded,
+			frame: artifact.frame,
+			binary: true,
+		};
+	}
+
+	return {
+		filename: artifact.filename,
+		stringContent: artifact.content,
+		frame: artifact.frame,
+		binary: false,
+	};
+};

package/src/stream-to-string.ts

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

package/src/streaming/streaming.ts

@@ -0,0 +1,148 @@
+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: Buffer;
+	  }
+	| {
+			type: typeof audioChunkRendered;
+			payload: Buffer;
+	  }
+	| {
+			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 Buffer);
+
+	return makeStreamPayloadMessage({
+		body,
+		nonce: messageTypeToMessageId(message.type),
+		status: 0,
+	});
+};

package/src/test/dont-contain-forbidden.test.ts

@@ -0,0 +1,14 @@
+import {expect, test} from 'bun:test';
+import path from 'path';
+
+test('Should not contain forbidden imports', async () => {
+	const output = await Bun.build({
+		external: ['@remotion/renderer', 'react/jsx-runtime'],
+		entrypoints: [path.join(__filename, '..', '..', 'index.ts')],
+	});
+	expect(output.outputs.length).toBe(1);
+	const text = await output.outputs[0].text();
+	expect(text).not.toContain('jsx-runtime');
+	expect(text).not.toContain('"@remotion/renderer"');
+	expect(text).not.toContain("'@remotion/renderer'");
+});

package/src/test/expected-out-name.test.ts

@@ -0,0 +1,197 @@
+import {expect, test} from 'bun:test';
+import {getExpectedOutName} from '../expected-out-name';
+import type {RenderMetadata} from '../render-metadata';
+
+const bucketName = 'remotionlambda-98fsduf';
+
+type MockProvider = {
+	type: 'aws';
+	region: 'eu-central';
+	receivedArtifactType: {
+		s3Key: string;
+		s3Url: string;
+	};
+	creationFunctionOptions: {};
+};
+
+const testRenderMetadata: RenderMetadata<MockProvider> = {
+	compositionId: 'react-svg',
+	estimatedRenderLambdaInvokations: 100,
+	estimatedTotalLambdaInvokations: 100,
+	framesPerLambda: 20,
+	imageFormat: 'png',
+	type: 'video',
+	inputProps: {
+		type: 'payload',
+		payload: '{}',
+	},
+	lambdaVersion: '2022-02-14',
+	memorySizeInMb: 2048,
+	functionName: 'remotion-render-4-0-187-mem3000mb-disk10000mb-120sec',
+	rendererFunctionName: 'remotion-render-4-0-187-mem3000mb-disk10000mb-120sec',
+	outName: undefined,
+	region: 'eu-central',
+	renderId: '9n8dsfafs',
+	siteId: 'my-site',
+	startedDate: Date.now(),
+	totalChunks: 20,
+	privacy: 'public',
+	everyNthFrame: 1,
+	frameRange: [0, 199],
+	audioCodec: null,
+	deleteAfter: null,
+	numberOfGifLoops: null,
+	downloadBehavior: {type: 'play-in-browser'},
+	audioBitrate: null,
+	muted: false,
+	metadata: null,
+	codec: 'h264',
+	dimensions: {
+		width: 1920,
+		height: 1080,
+	},
+};
+
+test('Should get a custom outname', () => {
+	expect(
+		getExpectedOutName({
+			renderMetadata: testRenderMetadata,
+			bucketName,
+			customCredentials: null,
+			bucketNamePrefix: 'remotionlambda-',
+		}),
+	).toEqual({
+		customCredentials: null,
+		renderBucketName: 'remotionlambda-98fsduf',
+		key: 'renders/9n8dsfafs/out.mp4',
+	});
+});
+
+test('Should save to a different outname', () => {
+	const newRenderMetadata: RenderMetadata<MockProvider> = {
+		...testRenderMetadata,
+		outName: {
+			bucketName: 'my-bucket',
+			key: 'my-key',
+		},
+	};
+	expect(
+		getExpectedOutName({
+			renderMetadata: newRenderMetadata,
+			bucketName,
+			customCredentials: null,
+			bucketNamePrefix: 'remotionlambda-',
+		}),
+	).toEqual({
+		customCredentials: null,
+		renderBucketName: 'my-bucket',
+		key: 'my-key',
+	});
+});
+
+test('For stills', () => {
+	const newRenderMetadata: RenderMetadata<MockProvider> = {
+		...testRenderMetadata,
+		codec: null,
+		type: 'still',
+		imageFormat: 'png',
+	};
+	expect(
+		getExpectedOutName({
+			renderMetadata: newRenderMetadata,
+			bucketName,
+			customCredentials: null,
+			bucketNamePrefix: 'remotionlambda-',
+		}),
+	).toEqual({
+		customCredentials: null,
+		renderBucketName: 'remotionlambda-98fsduf',
+		key: 'renders/9n8dsfafs/out.png',
+	});
+});
+
+test('Just a custom name', () => {
+	const newRenderMetadata: RenderMetadata<MockProvider> = {
+		...testRenderMetadata,
+		type: 'still',
+		imageFormat: 'jpeg',
+		codec: null,
+		outName: 'justaname.jpeg',
+	};
+	expect(
+		getExpectedOutName({
+			renderMetadata: newRenderMetadata,
+			bucketName,
+			customCredentials: null,
+			bucketNamePrefix: 'remotionlambda-',
+		}),
+	).toEqual({
+		customCredentials: null,
+		renderBucketName: 'remotionlambda-98fsduf',
+		key: 'renders/9n8dsfafs/justaname.jpeg',
+	});
+});
+
+test('Should throw on invalid names', () => {
+	const newRenderMetadata: RenderMetadata<MockProvider> = {
+		...testRenderMetadata,
+		type: 'still',
+		imageFormat: 'png',
+		codec: null,
+		outName: '👺.jpeg',
+	};
+	expect(() => {
+		getExpectedOutName({
+			renderMetadata: newRenderMetadata,
+			bucketName,
+			customCredentials: null,
+			bucketNamePrefix: 'remotionlambda-',
+		});
+	}).toThrow(/The S3 Key must match the RegExp/);
+});
+
+test('Should allow outName an outname with a slash', () => {
+	const newRenderMetadata: RenderMetadata<MockProvider> = {
+		...testRenderMetadata,
+		codec: null,
+		audioCodec: null,
+		type: 'still',
+		imageFormat: 'jpeg',
+		outName: 'justa/name.jpeg',
+	};
+	expect(
+		getExpectedOutName({
+			renderMetadata: newRenderMetadata,
+			bucketName,
+			customCredentials: null,
+			bucketNamePrefix: 'remotionlambda-',
+		}),
+	).toEqual({
+		customCredentials: null,
+		key: 'renders/9n8dsfafs/justa/name.jpeg',
+		renderBucketName: 'remotionlambda-98fsduf',
+	});
+});
+
+test('Should allow outName an outname with colon', () => {
+	const newRenderMetadata: RenderMetadata<MockProvider> = {
+		...testRenderMetadata,
+		codec: null,
+		audioCodec: null,
+		type: 'still' as const,
+		imageFormat: 'jpeg',
+		outName: 'ap-east-1:xxxxxx/video/XXXXX-0b9ba84XXXX.mp4',
+	};
+	expect(
+		getExpectedOutName({
+			renderMetadata: newRenderMetadata,
+			bucketName,
+			customCredentials: null,
+			bucketNamePrefix: 'remotionlambda-',
+		}),
+	).toEqual({
+		customCredentials: null,
+		key: 'renders/9n8dsfafs/ap-east-1:xxxxxx/video/XXXXX-0b9ba84XXXX.mp4',
+		renderBucketName: 'remotionlambda-98fsduf',
+	});
+});

package/src/test/min-max.test.ts

@@ -0,0 +1,25 @@
+import {describe, expect, test} from 'bun:test';
+import {max, min} from '../min-max';
+describe('min() and max()', () => {
+	test('Implemented min() functions correctly', () => {
+		expect(min([0, -30, 90, -120, 0])).toBe(-120);
+	});
+	test('Implemented max() functions correctly', () => {
+		expect(max([0, -30, 90, -120, 0])).toBe(90);
+	});
+
+	test('min() should throw on empty arr', () => {
+		expect(() => min([])).toThrow(/Array of 0 length/);
+	});
+	test('max() should throw on empty arr', () => {
+		expect(() => min([])).toThrow(/Array of 0 length/);
+	});
+
+	const bigArray = new Array(300000).fill(true).map((_, i) => {
+		return i;
+	});
+
+	test('Custom max() should not throw', () => {
+		expect(max(bigArray)).toBe(299999);
+	});
+});