@remotion/serverless-client 4.0.261

package/dist/render-has-audio-video.d.ts

@@ -0,0 +1,6 @@
+import type { RenderMetadata } from './render-metadata';
+import type { CloudProvider } from './types';
+export declare const lambdaRenderHasAudioVideo: <Provider extends CloudProvider>(renderMetadata: RenderMetadata<Provider>) => {
+    hasAudio: boolean;
+    hasVideo: boolean;
+};

package/dist/render-has-audio-video.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lambdaRenderHasAudioVideo = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+const lambdaRenderHasAudioVideo = (renderMetadata) => {
+    if (renderMetadata.type === 'still') {
+        throw new Error('Cannot merge stills');
+    }
+    const support = pure_1.NoReactAPIs.codecSupportsMedia(renderMetadata.codec);
+    const hasVideo = renderMetadata
+        ? !pure_1.NoReactAPIs.isAudioCodec(renderMetadata.codec)
+        : false;
+    const hasAudio = renderMetadata
+        ? !renderMetadata.muted && support.audio
+        : false;
+    return {
+        hasAudio,
+        hasVideo,
+    };
+};
+exports.lambdaRenderHasAudioVideo = lambdaRenderHasAudioVideo;

package/dist/render-metadata.d.ts

@@ -0,0 +1,45 @@
+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;
+};
+export {};

package/dist/render-metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/render-progress.d.ts

@@ -0,0 +1,51 @@
+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>[];
+};
+export {};

package/dist/render-progress.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/return-values.d.ts

@@ -0,0 +1,38 @@
+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/dist/return-values.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/serialize-artifact.d.ts

@@ -0,0 +1,9 @@
+import type { EmittedArtifact } from '@remotion/renderer';
+export type SerializedArtifact = {
+    filename: string;
+    stringContent: string;
+    frame: number;
+    binary: boolean;
+};
+export declare const deserializeArtifact: (serializedArtifact: SerializedArtifact) => EmittedArtifact;
+export declare const serializeArtifact: (artifact: EmittedArtifact) => SerializedArtifact;

package/dist/serialize-artifact.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeArtifact = exports.deserializeArtifact = void 0;
+const deserializeArtifact = (serializedArtifact) => {
+    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,
+    };
+};
+exports.deserializeArtifact = deserializeArtifact;
+const serializeArtifact = (artifact) => {
+    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,
+    };
+};
+exports.serializeArtifact = serializeArtifact;

package/dist/stream-to-string.d.ts

@@ -0,0 +1,2 @@
+import type { Readable } from 'stream';
+export declare function streamToString(stream: Readable | Buffer): string | Promise<string>;

package/dist/stream-to-string.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamToString = streamToString;
+function streamToString(stream) {
+    if (Buffer.isBuffer(stream)) {
+        return stream.toString('utf-8');
+    }
+    const chunks = [];
+    return new Promise((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/dist/streaming/streaming.d.ts

@@ -0,0 +1,101 @@
+import type { SerializedArtifact } from '../serialize-artifact';
+import type { CloudProvider, RenderStillFunctionResponsePayload } from '../types';
+import type { FunctionErrorInfo } from '../write-error-to-storage';
+declare const framesRendered: "frames-rendered";
+declare const errorOccurred: "error-occurred";
+declare const renderIdDetermined: "render-id-determined";
+declare const videoChunkRendered: "video-chunk-rendered";
+declare const audioChunkRendered: "audio-chunk-rendered";
+declare const chunkComplete: "chunk-complete";
+declare const stillRendered: "still-rendered";
+declare const functionInvoked: "lambda-invoked";
+declare const artifactEmitted: "artifact-emitted";
+declare const messageTypes: {
+    readonly '1': {
+        readonly type: "frames-rendered";
+    };
+    readonly '2': {
+        readonly type: "error-occurred";
+    };
+    readonly '3': {
+        readonly type: "render-id-determined";
+    };
+    readonly '4': {
+        readonly type: "video-chunk-rendered";
+    };
+    readonly '5': {
+        readonly type: "audio-chunk-rendered";
+    };
+    readonly '6': {
+        readonly type: "still-rendered";
+    };
+    readonly '7': {
+        readonly type: "chunk-complete";
+    };
+    readonly '8': {
+        readonly type: "lambda-invoked";
+    };
+    readonly '9': {
+        readonly type: "artifact-emitted";
+    };
+};
+export type MessageTypeId = keyof typeof messageTypes;
+type MessageType = (typeof messageTypes)[MessageTypeId]['type'];
+export declare const formatMap: {
+    [key in MessageType]: 'json' | 'binary';
+};
+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 declare const messageTypeIdToMessageType: (messageTypeId: MessageTypeId) => MessageType;
+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 declare const makeStreamPayload: <Provider extends CloudProvider>({ message, }: {
+    message: StreamingPayload<Provider>;
+}) => Uint8Array;
+export {};

package/dist/streaming/streaming.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStreamPayload = exports.messageTypeIdToMessageType = exports.formatMap = void 0;
+const streaming_1 = require("@remotion/streaming");
+const framesRendered = 'frames-rendered';
+const errorOccurred = 'error-occurred';
+const renderIdDetermined = 'render-id-determined';
+const videoChunkRendered = 'video-chunk-rendered';
+const audioChunkRendered = 'audio-chunk-rendered';
+const chunkComplete = 'chunk-complete';
+const stillRendered = 'still-rendered';
+const functionInvoked = 'lambda-invoked';
+const artifactEmitted = 'artifact-emitted';
+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 },
+};
+exports.formatMap = {
+    [framesRendered]: 'json',
+    [errorOccurred]: 'json',
+    [renderIdDetermined]: 'json',
+    [videoChunkRendered]: 'binary',
+    [audioChunkRendered]: 'binary',
+    [stillRendered]: 'json',
+    [chunkComplete]: 'json',
+    [functionInvoked]: 'json',
+    [artifactEmitted]: 'json',
+};
+const messageTypeIdToMessageType = (messageTypeId) => {
+    const types = messageTypes[messageTypeId];
+    if (!types) {
+        throw new Error(`Unknown message type id ${messageTypeId}`);
+    }
+    return types.type;
+};
+exports.messageTypeIdToMessageType = messageTypeIdToMessageType;
+const messageTypeToMessageId = (messageType) => {
+    const id = Object.keys(messageTypes).find((key) => messageTypes[key].type === messageType);
+    if (!id) {
+        throw new Error(`Unknown message type ${messageType}`);
+    }
+    return id;
+};
+const makeStreamPayload = ({ message, }) => {
+    const body = exports.formatMap[message.type] === 'json'
+        ? new TextEncoder().encode(JSON.stringify(message.payload))
+        : message.payload;
+    return (0, streaming_1.makeStreamPayloadMessage)({
+        body,
+        nonce: messageTypeToMessageId(message.type),
+        status: 0,
+    });
+};
+exports.makeStreamPayload = makeStreamPayload;

package/dist/test/dont-contain-forbidden.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/dont-contain-forbidden.test.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const path_1 = __importDefault(require("path"));
+(0, bun_test_1.test)('Should not contain forbidden imports', async () => {
+    const output = await Bun.build({
+        external: ['@remotion/renderer', 'react/jsx-runtime'],
+        entrypoints: [path_1.default.join(__filename, '..', '..', 'index.ts')],
+    });
+    (0, bun_test_1.expect)(output.outputs.length).toBe(1);
+    const text = await output.outputs[0].text();
+    (0, bun_test_1.expect)(text).not.toContain('jsx-runtime');
+    (0, bun_test_1.expect)(text).not.toContain('"@remotion/renderer"');
+    (0, bun_test_1.expect)(text).not.toContain("'@remotion/renderer'");
+});

package/dist/test/expected-out-name.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/expected-out-name.test.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const expected_out_name_1 = require("../expected-out-name");
+const bucketName = 'remotionlambda-98fsduf';
+const testRenderMetadata = {
+    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,
+    },
+};
+(0, bun_test_1.test)('Should get a custom outname', () => {
+    (0, bun_test_1.expect)((0, expected_out_name_1.getExpectedOutName)({
+        renderMetadata: testRenderMetadata,
+        bucketName,
+        customCredentials: null,
+        bucketNamePrefix: 'remotionlambda-',
+    })).toEqual({
+        customCredentials: null,
+        renderBucketName: 'remotionlambda-98fsduf',
+        key: 'renders/9n8dsfafs/out.mp4',
+    });
+});
+(0, bun_test_1.test)('Should save to a different outname', () => {
+    const newRenderMetadata = {
+        ...testRenderMetadata,
+        outName: {
+            bucketName: 'my-bucket',
+            key: 'my-key',
+        },
+    };
+    (0, bun_test_1.expect)((0, expected_out_name_1.getExpectedOutName)({
+        renderMetadata: newRenderMetadata,
+        bucketName,
+        customCredentials: null,
+        bucketNamePrefix: 'remotionlambda-',
+    })).toEqual({
+        customCredentials: null,
+        renderBucketName: 'my-bucket',
+        key: 'my-key',
+    });
+});
+(0, bun_test_1.test)('For stills', () => {
+    const newRenderMetadata = {
+        ...testRenderMetadata,
+        codec: null,
+        type: 'still',
+        imageFormat: 'png',
+    };
+    (0, bun_test_1.expect)((0, expected_out_name_1.getExpectedOutName)({
+        renderMetadata: newRenderMetadata,
+        bucketName,
+        customCredentials: null,
+        bucketNamePrefix: 'remotionlambda-',
+    })).toEqual({
+        customCredentials: null,
+        renderBucketName: 'remotionlambda-98fsduf',
+        key: 'renders/9n8dsfafs/out.png',
+    });
+});
+(0, bun_test_1.test)('Just a custom name', () => {
+    const newRenderMetadata = {
+        ...testRenderMetadata,
+        type: 'still',
+        imageFormat: 'jpeg',
+        codec: null,
+        outName: 'justaname.jpeg',
+    };
+    (0, bun_test_1.expect)((0, expected_out_name_1.getExpectedOutName)({
+        renderMetadata: newRenderMetadata,
+        bucketName,
+        customCredentials: null,
+        bucketNamePrefix: 'remotionlambda-',
+    })).toEqual({
+        customCredentials: null,
+        renderBucketName: 'remotionlambda-98fsduf',
+        key: 'renders/9n8dsfafs/justaname.jpeg',
+    });
+});
+(0, bun_test_1.test)('Should throw on invalid names', () => {
+    const newRenderMetadata = {
+        ...testRenderMetadata,
+        type: 'still',
+        imageFormat: 'png',
+        codec: null,
+        outName: '👺.jpeg',
+    };
+    (0, bun_test_1.expect)(() => {
+        (0, expected_out_name_1.getExpectedOutName)({
+            renderMetadata: newRenderMetadata,
+            bucketName,
+            customCredentials: null,
+            bucketNamePrefix: 'remotionlambda-',
+        });
+    }).toThrow(/The S3 Key must match the RegExp/);
+});
+(0, bun_test_1.test)('Should allow outName an outname with a slash', () => {
+    const newRenderMetadata = {
+        ...testRenderMetadata,
+        codec: null,
+        audioCodec: null,
+        type: 'still',
+        imageFormat: 'jpeg',
+        outName: 'justa/name.jpeg',
+    };
+    (0, bun_test_1.expect)((0, expected_out_name_1.getExpectedOutName)({
+        renderMetadata: newRenderMetadata,
+        bucketName,
+        customCredentials: null,
+        bucketNamePrefix: 'remotionlambda-',
+    })).toEqual({
+        customCredentials: null,
+        key: 'renders/9n8dsfafs/justa/name.jpeg',
+        renderBucketName: 'remotionlambda-98fsduf',
+    });
+});
+(0, bun_test_1.test)('Should allow outName an outname with colon', () => {
+    const newRenderMetadata = {
+        ...testRenderMetadata,
+        codec: null,
+        audioCodec: null,
+        type: 'still',
+        imageFormat: 'jpeg',
+        outName: 'ap-east-1:xxxxxx/video/XXXXX-0b9ba84XXXX.mp4',
+    };
+    (0, bun_test_1.expect)((0, expected_out_name_1.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/dist/test/min-max.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/min-max.test.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const min_max_1 = require("../min-max");
+(0, bun_test_1.describe)('min() and max()', () => {
+    (0, bun_test_1.test)('Implemented min() functions correctly', () => {
+        (0, bun_test_1.expect)((0, min_max_1.min)([0, -30, 90, -120, 0])).toBe(-120);
+    });
+    (0, bun_test_1.test)('Implemented max() functions correctly', () => {
+        (0, bun_test_1.expect)((0, min_max_1.max)([0, -30, 90, -120, 0])).toBe(90);
+    });
+    (0, bun_test_1.test)('min() should throw on empty arr', () => {
+        (0, bun_test_1.expect)(() => (0, min_max_1.min)([])).toThrow(/Array of 0 length/);
+    });
+    (0, bun_test_1.test)('max() should throw on empty arr', () => {
+        (0, bun_test_1.expect)(() => (0, min_max_1.min)([])).toThrow(/Array of 0 length/);
+    });
+    const bigArray = new Array(300000).fill(true).map((_, i) => {
+        return i;
+    });
+    (0, bun_test_1.test)('Custom max() should not throw', () => {
+        (0, bun_test_1.expect)((0, min_max_1.max)(bigArray)).toBe(299999);
+    });
+});

package/dist/test/most-expensive-chunks.test.d.ts

@@ -0,0 +1 @@
+export {};