@remotion/lambda 4.0.187 → 4.0.189

package/dist/functions/helpers/overall-render-progress.d.ts

@@ -1,10 +1,10 @@
 import type { LogLevel } from '@remotion/renderer';
-import type { AwsRegion } from '../../client';
-import type { PostRenderData, RenderMetadata } from '../../shared/constants';
+import type { CloudProvider, LambdaErrorInfo, ProviderSpecifics, ReceivedArtifact } from '@remotion/serverless';
+import { type RenderMetadata } from '@remotion/serverless/client';
+import type { PostRenderData } from '../../shared/constants';
 import type { ParsedTiming } from '../../shared/parse-lambda-timings-key';
 import type { ChunkRetry } from './get-retry-stats';
-import type { LambdaErrorInfo } from './write-lambda-error';
-export type OverallRenderProgress = {
+export type OverallRenderProgress<Provider extends CloudProvider> = {
     chunks: number[];
     framesRendered: number;
     framesEncoded: number;
@@ -14,23 +14,17 @@ export type OverallRenderProgress = {
     timeToRenderFrames: number | null;
     lambdasInvoked: number;
     retries: ChunkRetry[];
-    postRenderData: PostRenderData | null;
+    postRenderData: PostRenderData<Provider> | null;
     timings: ParsedTiming[];
-    renderMetadata: RenderMetadata | null;
+    renderMetadata: RenderMetadata<Provider> | null;
     errors: LambdaErrorInfo[];
     timeoutTimestamp: number;
     functionLaunched: number;
     serveUrlOpened: number | null;
     compositionValidated: number | null;
-    receivedArtifact: ReceivedArtifact[];
+    receivedArtifact: ReceivedArtifact<Provider>[];
 };
-export type ReceivedArtifact = {
-    filename: string;
-    sizeInBytes: number;
-    s3Url: string;
-    s3Key: string;
-};
-export type OverallProgressHelper = {
+export type OverallProgressHelper<Provider extends CloudProvider> = {
     upload: () => Promise<void>;
     setFrames: ({ encoded, rendered, index, }: {
         rendered: number;
@@ -42,22 +36,23 @@ export type OverallProgressHelper = {
     setCombinedFrames: (framesEncoded: number) => void;
     setTimeToCombine: (timeToCombine: number) => void;
     addRetry: (retry: ChunkRetry) => void;
-    setPostRenderData: (postRenderData: PostRenderData) => void;
-    setRenderMetadata: (renderMetadata: RenderMetadata) => void;
+    setPostRenderData: (postRenderData: PostRenderData<Provider>) => void;
+    setRenderMetadata: (renderMetadata: RenderMetadata<Provider>) => void;
     addErrorWithoutUpload: (errorInfo: LambdaErrorInfo) => void;
     setExpectedChunks: (expectedChunks: number) => void;
-    get: () => OverallRenderProgress;
+    get: () => OverallRenderProgress<Provider>;
     setServeUrlOpened: (timestamp: number) => void;
     setCompositionValidated: (timestamp: number) => void;
-    addReceivedArtifact: (asset: ReceivedArtifact) => void;
-    getReceivedArtifacts: () => ReceivedArtifact[];
+    addReceivedArtifact: (asset: ReceivedArtifact<Provider>) => void;
+    getReceivedArtifacts: () => ReceivedArtifact<Provider>[];
 };
-export declare const makeInitialOverallRenderProgress: (timeoutTimestamp: number) => OverallRenderProgress;
-export declare const makeOverallRenderProgress: ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, }: {
+export declare const makeInitialOverallRenderProgress: <Provider extends CloudProvider<string, Record<string, unknown>>>(timeoutTimestamp: number) => OverallRenderProgress<Provider>;
+export declare const makeOverallRenderProgress: <Provider extends CloudProvider<string, Record<string, unknown>>>({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, }: {
     renderId: string;
     bucketName: string;
     expectedBucketOwner: string;
-    region: AwsRegion;
+    region: Provider["region"];
     timeoutTimestamp: number;
     logLevel: LogLevel;
-}) => OverallProgressHelper;
+    providerSpecifics: ProviderSpecifics<Provider>;
+}) => OverallProgressHelper<Provider>;

package/dist/functions/helpers/overall-render-progress.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeOverallRenderProgress = exports.makeInitialOverallRenderProgress = void 0;
 const renderer_1 = require("@remotion/renderer");
-const constants_1 = require("../../shared/constants");
-const io_1 = require("./io");
+const client_1 = require("@remotion/serverless/client");
 const makeInitialOverallRenderProgress = (timeoutTimestamp) => {
     return {
         chunks: [],
@@ -27,7 +26,7 @@ const makeInitialOverallRenderProgress = (timeoutTimestamp) => {
     };
 };
 exports.makeInitialOverallRenderProgress = makeInitialOverallRenderProgress;
-const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, }) => {
+const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, }) => {
     let framesRendered = [];
     let framesEncoded = [];
     let lambdasInvoked = [];
@@ -49,13 +48,14 @@ const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner,
         }
         const toWrite = JSON.stringify(getCurrentProgress());
         const start = Date.now();
-        currentUploadPromise = (0, io_1.lambdaWriteFile)({
+        currentUploadPromise = providerSpecifics
+            .writeFile({
             body: toWrite,
             bucketName,
             customCredentials: null,
             downloadBehavior: null,
             expectedBucketOwner,
-            key: (0, constants_1.overallProgressKey)(renderId),
+            key: (0, client_1.overallProgressKey)(renderId),
             privacy: 'private',
             region,
         })

package/dist/functions/helpers/print-cloudwatch-helper.d.ts

@@ -1,3 +1,3 @@
 import type { LogLevel } from '@remotion/renderer';
-import type { LambdaRoutines } from '../../defaults';
-export declare const printCloudwatchHelper: (type: LambdaRoutines, data: Record<string, string | boolean>, logLevel: LogLevel) => void;
+import type { ServerlessRoutines } from '@remotion/serverless/client';
+export declare const printCloudwatchHelper: (type: ServerlessRoutines, data: Record<string, string | boolean>, logLevel: LogLevel) => void;

package/dist/functions/helpers/print-logging-helper.d.ts

@@ -0,0 +1,4 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { ServerlessRoutines } from '@remotion/serverless/client';
+export type PrintLoggingHelper = (type: ServerlessRoutines, data: Record<string, string | boolean>, logLevel: LogLevel) => void;
+export declare const printLoggingGrepHelper: PrintLoggingHelper;

package/dist/functions/helpers/print-logging-helper.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printLoggingGrepHelper = void 0;
+const renderer_1 = require("@remotion/renderer");
+const printLoggingGrepHelper = (type, data, logLevel) => {
+    const d = Object.keys(data).reduce((a, b) => {
+        return [...a, `${b}=${data[b]}`];
+    }, []);
+    const msg = [`method=${type}`, ...d].join(',');
+    renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, msg);
+};
+exports.printLoggingGrepHelper = printLoggingGrepHelper;

package/dist/functions/helpers/read-with-progress.d.ts

@@ -1,6 +1,7 @@
 import type { LogLevel } from '@remotion/renderer';
-import type { AwsRegion } from '../../pricing/aws-regions';
-import type { CustomCredentials } from '../../shared/aws-clients';
+import type { CustomCredentials } from '@remotion/serverless/client';
+import type { AwsRegion } from '../../regions';
+import type { AwsProvider } from '../aws-implementation';
 export type LambdaReadFileProgress = (progress: {
     totalSize: number;
     downloaded: number;
@@ -13,7 +14,7 @@ export declare const lambdaDownloadFileWithProgress: ({ bucketName, key, region,
     expectedBucketOwner: string;
     outputPath: string;
     onProgress: LambdaReadFileProgress;
-    customCredentials: CustomCredentials | null;
+    customCredentials: CustomCredentials<AwsProvider> | null;
     logLevel: LogLevel;
 }) => Promise<{
     sizeInBytes: number;

package/dist/functions/helpers/read-with-progress.js

@@ -4,9 +4,9 @@ exports.lambdaDownloadFileWithProgress = void 0;
 const client_s3_1 = require("@aws-sdk/client-s3");
 const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
 const renderer_1 = require("@remotion/renderer");
-const aws_clients_1 = require("../../shared/aws-clients");
+const get_s3_client_1 = require("../../shared/get-s3-client");
 const lambdaDownloadFileWithProgress = async ({ bucketName, key, region, expectedBucketOwner, outputPath, onProgress, customCredentials, logLevel, }) => {
-    const client = (0, aws_clients_1.getS3Client)(region, customCredentials);
+    const client = (0, get_s3_client_1.getS3Client)(region, customCredentials);
     const command = new client_s3_1.GetObjectCommand({
         Bucket: bucketName,
         ExpectedBucketOwner: customCredentials ? undefined : expectedBucketOwner,

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

@@ -1,5 +1,6 @@
-import type { RenderMetadata } from '../../defaults';
-export declare const lambdaRenderHasAudioVideo: (renderMetadata: RenderMetadata) => {
+import type { CloudProvider } from '@remotion/serverless';
+import type { RenderMetadata } from '@remotion/serverless/client';
+export declare const lambdaRenderHasAudioVideo: <Provider extends CloudProvider<string, Record<string, unknown>>>(renderMetadata: RenderMetadata<Provider>) => {
     hasAudio: boolean;
     hasVideo: boolean;
 };

package/dist/functions/helpers/stream-renderer.d.ts

@@ -1,14 +1,17 @@
 import type { EmittedArtifact, LogLevel } from '@remotion/renderer';
-import type { LambdaPayload } from '../../defaults';
+import type { CloudProvider } from '@remotion/serverless';
+import { type ProviderSpecifics } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
 import type { OverallProgressHelper } from './overall-render-progress';
-export declare const streamRendererFunctionWithRetry: ({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, }: {
-    payload: LambdaPayload;
+export declare const streamRendererFunctionWithRetry: <Provider extends CloudProvider<string, Record<string, unknown>>>({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, }: {
+    payload: ServerlessPayload<Provider>;
     functionName: string;
     outdir: string;
-    overallProgress: OverallProgressHelper;
+    overallProgress: OverallProgressHelper<Provider>;
     files: string[];
     logLevel: LogLevel;
     onArtifact: (asset: EmittedArtifact) => {
         alreadyExisted: boolean;
     };
+    providerSpecifics: ProviderSpecifics<Provider>;
 }) => Promise<unknown>;

package/dist/functions/helpers/stream-renderer.js

@@ -2,14 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.streamRendererFunctionWithRetry = void 0;
 const renderer_1 = require("@remotion/renderer");
+const serverless_1 = require("@remotion/serverless");
+const client_1 = require("@remotion/serverless/client");
 const fs_1 = require("fs");
 const path_1 = require("path");
-const defaults_1 = require("../../defaults");
 const call_lambda_1 = require("../../shared/call-lambda");
-const get_current_region_1 = require("./get-current-region");
-const serialize_artifact_1 = require("./serialize-artifact");
-const streamRenderer = ({ payload, functionName, outdir, overallProgress, files, logLevel, onArtifact, }) => {
-    if (payload.type !== defaults_1.LambdaRoutines.renderer) {
+const streamRenderer = ({ payload, functionName, outdir, overallProgress, files, logLevel, onArtifact, providerSpecifics, }) => {
+    if (payload.type !== client_1.ServerlessRoutines.renderer) {
         throw new Error('Expected renderer type');
     }
     return new Promise((resolve) => {
@@ -46,7 +45,7 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
                 return;
             }
             if (message.type === 'artifact-emitted') {
-                const artifact = (0, serialize_artifact_1.deserializeArtifact)(message.payload.artifact);
+                const artifact = (0, serverless_1.deserializeArtifact)(message.payload.artifact);
                 renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Received artifact on frame ${message.payload.artifact.frame}:`, artifact.filename, artifact.content.length + 'bytes.');
                 const { alreadyExisted } = onArtifact(artifact);
                 if (alreadyExisted) {
@@ -86,9 +85,9 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
             functionName,
             payload,
             retriesRemaining: 1,
-            region: (0, get_current_region_1.getCurrentRegionInFunction)(),
+            region: providerSpecifics.getCurrentRegionInFunction(),
             timeoutInTest: 12000,
-            type: defaults_1.LambdaRoutines.renderer,
+            type: client_1.ServerlessRoutines.renderer,
             receivedStreamingPayload,
         })
             .then(() => {
@@ -105,8 +104,8 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
         });
     });
 };
-const streamRendererFunctionWithRetry = async ({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, }) => {
-    if (payload.type !== defaults_1.LambdaRoutines.renderer) {
+const streamRendererFunctionWithRetry = async ({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, }) => {
+    if (payload.type !== client_1.ServerlessRoutines.renderer) {
         throw new Error('Expected renderer type');
     }
     const result = await streamRenderer({
@@ -117,6 +116,7 @@ const streamRendererFunctionWithRetry = async ({ payload, files, functionName, o
         payload,
         logLevel,
         onArtifact,
+        providerSpecifics,
     });
     if (result.type === 'error') {
         if (!result.shouldRetry) {
@@ -139,6 +139,7 @@ const streamRendererFunctionWithRetry = async ({ payload, files, functionName, o
             },
             logLevel,
             onArtifact,
+            providerSpecifics,
         });
     }
 };

package/dist/functions/helpers/streamify-response.d.ts

@@ -1,21 +1 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Writable } from 'stream';
-type Chunk = {
-    PayloadChunk: {
-        Payload: string | Buffer | null;
-    };
-    InvokeComplete: boolean;
-};
-export declare class ResponseStream extends Writable {
-    private queue;
-    private waitingResolve;
-    private response;
-    constructor();
-    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    _finish(): void;
-    getBufferedData(): Buffer;
-    [Symbol.asyncIterator](): AsyncGenerator<Chunk, void, void>;
-}
 export declare function streamifyResponse(handler: Function): Function;
-export {};

package/dist/functions/helpers/streamify-response.js

@@ -1,67 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamifyResponse = exports.ResponseStream = void 0;
-const stream_1 = require("stream");
-class ResponseStream extends stream_1.Writable {
-    constructor() {
-        super();
-        this.queue = [];
-        this.waitingResolve = [];
-        this.response = [];
-    }
-    _write(chunk, encoding, callback) {
-        const data = Buffer.from(chunk, encoding);
-        const resolve = this.waitingResolve.shift();
-        if (resolve) {
-            resolve({ PayloadChunk: { Payload: data }, InvokeComplete: false });
-        }
-        else {
-            this.queue.push({ PayloadChunk: { Payload: data }, InvokeComplete: false });
-        }
-        this.response.push(Buffer.from(chunk, encoding));
-        callback();
-    }
-    _finish() {
-        const resolve = this.waitingResolve.shift();
-        if (resolve) {
-            resolve({ PayloadChunk: { Payload: null }, InvokeComplete: true });
-        }
-        else {
-            this.queue.push({ PayloadChunk: { Payload: null }, InvokeComplete: true });
-        }
-    }
-    getBufferedData() {
-        return Buffer.concat(this.response);
-    }
-    async *[Symbol.asyncIterator]() {
-        while (true) {
-            if (this.queue.length > 0) {
-                const shifted = this.queue.shift();
-                yield shifted;
-                if (shifted.InvokeComplete) {
-                    break;
-                }
-            }
-            else {
-                // Wait for new data to be written
-                const shifted = await new Promise((resolve) => {
-                    this.waitingResolve.push((data) => {
-                        Promise.resolve(data).then((d) => {
-                            if (d) {
-                                resolve(d);
-                            }
-                        });
-                    });
-                });
-                yield shifted;
-                if (shifted.InvokeComplete) {
-                    break;
-                }
-            }
-        }
-    }
-}
-exports.ResponseStream = ResponseStream;
+exports.streamifyResponse = void 0;
 function streamifyResponse(handler) {
     // Check if we are inside Lambda
     if (process.env.AWS_LAMBDA_FUNCTION_VERSION &&

package/dist/functions/helpers/validate-composition.d.ts

@@ -1,7 +1,8 @@
 import type { ChromiumOptions, LogLevel, OnBrowserDownload, openBrowser, RemotionServer } from '@remotion/renderer';
+import type { ProviderSpecifics } from '@remotion/serverless';
+import type { Await } from '@remotion/serverless/client';
 import type { VideoConfig } from 'remotion/no-react';
-import type { Await } from '../../shared/await';
-type ValidateCompositionOptions = {
+type ValidateCompositionOptions<Region extends string> = {
     serveUrl: string;
     composition: string;
     browserInstance: Await<ReturnType<typeof openBrowser>>;
@@ -17,6 +18,7 @@ type ValidateCompositionOptions = {
     offthreadVideoCacheSizeInBytes: number | null;
     onBrowserDownload: OnBrowserDownload;
     onServeUrlVisited: () => void;
+    providerSpecifics: ProviderSpecifics<Region>;
 };
-export declare const validateComposition: ({ serveUrl, composition, browserInstance, serializedInputPropsWithCustomSchema, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, offthreadVideoCacheSizeInBytes, onBrowserDownload, onServeUrlVisited, }: ValidateCompositionOptions) => Promise<VideoConfig>;
+export declare const validateComposition: <Region extends string>({ serveUrl, composition, browserInstance, serializedInputPropsWithCustomSchema, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, offthreadVideoCacheSizeInBytes, onBrowserDownload, onServeUrlVisited, providerSpecifics, }: ValidateCompositionOptions<Region>) => Promise<VideoConfig>;
 export {};

package/dist/functions/helpers/validate-composition.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateComposition = void 0;
 const renderer_1 = require("@remotion/renderer");
-const get_chromium_executable_path_1 = require("./get-chromium-executable-path");
-const validateComposition = async ({ serveUrl, composition, browserInstance, serializedInputPropsWithCustomSchema, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, offthreadVideoCacheSizeInBytes, onBrowserDownload, onServeUrlVisited, }) => {
+const validateComposition = async ({ serveUrl, composition, browserInstance, serializedInputPropsWithCustomSchema, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, offthreadVideoCacheSizeInBytes, onBrowserDownload, onServeUrlVisited, providerSpecifics, }) => {
     const { metadata: comp } = await renderer_1.RenderInternals.internalSelectComposition({
         id: composition,
         puppeteerInstance: browserInstance,
@@ -12,7 +11,7 @@ const validateComposition = async ({ serveUrl, composition, browserInstance, ser
         timeoutInMilliseconds,
         chromiumOptions,
         port,
-        browserExecutable: (0, get_chromium_executable_path_1.executablePath)(),
+        browserExecutable: providerSpecifics.getChromiumPath(),
         serveUrl,
         logLevel,
         indent: false,

package/dist/functions/index.d.ts

@@ -1,10 +1,12 @@
-import type { LambdaPayload } from '../shared/constants';
+import type { CloudProvider, ProviderSpecifics, ResponseStream } from '@remotion/serverless';
+import type { ServerlessPayload } from '@remotion/serverless/client';
+import type { AwsProvider } from './aws-implementation';
 import type { RequestContext } from './helpers/request-context';
-import type { ResponseStream } from './helpers/streamify-response';
 export type OrError<T> = T | {
     type: 'error';
     message: string;
     stack: string;
 };
-export declare const routine: (params: LambdaPayload, responseStream: ResponseStream, context: RequestContext) => Promise<void>;
+export declare const innerRoutine: <Provider extends CloudProvider<string, Record<string, unknown>>>(params: ServerlessPayload<Provider>, responseStream: ResponseStream, context: RequestContext, providerSpecifics: ProviderSpecifics<Provider>) => Promise<void>;
+export declare const routine: (params: ServerlessPayload<AwsProvider>, responseStream: ResponseStream, context: RequestContext) => Promise<void>;
 export declare const handler: Function;