@remotion/serverless 4.0.245 → 4.0.246

package/dist/inner-routine.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.innerRoutine = exports.innerHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const client_1 = require("./client");
+const constants_1 = require("./constants");
+const compositions_1 = require("./handlers/compositions");
+const launch_1 = require("./handlers/launch");
+const progress_1 = require("./handlers/progress");
+const renderer_2 = require("./handlers/renderer");
+const start_1 = require("./handlers/start");
+const still_1 = require("./handlers/still");
+const info_1 = require("./info");
+const is_warm_1 = require("./is-warm");
+const leak_detection_1 = require("./leak-detection");
+const print_logging_grep_helper_1 = require("./print-logging-grep-helper");
+const innerHandler = async ({ params, responseWriter, context, providerSpecifics, insideFunctionSpecifics, webhookClient, }) => {
+    (0, leak_detection_1.setCurrentRequestId)(context.awsRequestId);
+    process.env.__RESERVED_IS_INSIDE_REMOTION_LAMBDA = 'true';
+    const timeoutInMilliseconds = context.getRemainingTimeInMillis();
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'AWS Request ID:', context.awsRequestId);
+    (0, leak_detection_1.stopLeakDetection)();
+    if (!(context === null || context === void 0 ? void 0 : context.invokedFunctionArn)) {
+        throw new Error('Lambda function unexpectedly does not have context.invokedFunctionArn');
+    }
+    await insideFunctionSpecifics.deleteTmpDir();
+    const isWarm = (0, is_warm_1.getWarm)();
+    (0, is_warm_1.setWarm)();
+    const currentUserId = context.invokedFunctionArn.split(':')[4];
+    if (params.type === constants_1.ServerlessRoutines.still) {
+        providerSpecifics.validateDeleteAfter(params.deleteAfter);
+        const renderId = insideFunctionSpecifics.generateRandomId({
+            deleteAfter: params.deleteAfter,
+            randomHashFn: providerSpecifics.randomHash,
+        });
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.still, {
+                renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        try {
+            await new Promise((resolve, reject) => {
+                const onStream = async (payload) => {
+                    if (!params.streamed) {
+                        if (payload.type !== 'still-rendered') {
+                            throw new Error('Expected still-rendered');
+                        }
+                        await responseWriter.write(Buffer.from(JSON.stringify(payload.payload)));
+                        return;
+                    }
+                    const message = (0, client_1.makeStreamPayload)({
+                        message: payload,
+                    });
+                    return new Promise((innerResolve, innerReject) => {
+                        responseWriter
+                            .write(message)
+                            .then(() => {
+                            innerResolve();
+                        })
+                            .catch((err) => {
+                            reject(err);
+                            innerReject(err);
+                        });
+                    });
+                };
+                if (params.streamed) {
+                    onStream({
+                        type: 'render-id-determined',
+                        payload: { renderId },
+                    });
+                }
+                (0, still_1.stillHandler)({
+                    expectedBucketOwner: currentUserId,
+                    params,
+                    renderId,
+                    onStream,
+                    timeoutInMilliseconds,
+                    providerSpecifics,
+                    insideFunctionSpecifics,
+                })
+                    .then((r) => {
+                    resolve(r);
+                })
+                    .catch((err) => {
+                    reject(err);
+                });
+            });
+            await responseWriter.end();
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.log({ err });
+        }
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.start) {
+        const renderId = insideFunctionSpecifics.generateRandomId({
+            deleteAfter: params.deleteAfter,
+            randomHashFn: providerSpecifics.randomHash,
+        });
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.start, {
+                renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, start_1.startHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+                timeoutInMilliseconds,
+                renderId,
+            },
+            providerSpecifics,
+            insideFunctionSpecifics,
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.launch) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.launch, {
+                renderId: params.renderId,
+                inputProps: JSON.stringify(params.inputProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, launch_1.launchHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+                getRemainingTimeInMillis: context.getRemainingTimeInMillis,
+            },
+            providerSpecifics,
+            client: webhookClient,
+            insideFunctionSpecifics,
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.status) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.status, {
+                renderId: params.renderId,
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, progress_1.progressHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+                timeoutInMilliseconds,
+                retriesRemaining: 2,
+                providerSpecifics,
+                insideFunctionSpecifics,
+            },
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.renderer) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.renderer, {
+                renderId: params.renderId,
+                chunk: String(params.chunk),
+                dumpLogs: String(renderer_1.RenderInternals.isEqualOrBelowLogLevel(params.logLevel, 'verbose')),
+                resolvedProps: JSON.stringify(params.resolvedProps),
+                isWarm,
+            }, params.logLevel);
+        }
+        await new Promise((resolve, reject) => {
+            (0, renderer_2.rendererHandler)({
+                params,
+                options: {
+                    expectedBucketOwner: currentUserId,
+                    isWarm,
+                },
+                onStream: (payload) => {
+                    const message = (0, client_1.makeStreamPayload)({
+                        message: payload,
+                    });
+                    const writeProm = responseWriter.write(message);
+                    return new Promise((innerResolve, innerReject) => {
+                        writeProm
+                            .then(() => {
+                            innerResolve();
+                        })
+                            .catch((err) => {
+                            reject(err);
+                            innerReject(err);
+                        });
+                    });
+                },
+                requestContext: context,
+                providerSpecifics,
+                insideFunctionSpecifics,
+            })
+                .then((res) => {
+                resolve(res);
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        });
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.info) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.info, {
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, info_1.infoHandler)(params);
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    if (params.type === constants_1.ServerlessRoutines.compositions) {
+        if (providerSpecifics.printLoggingHelper) {
+            (0, print_logging_grep_helper_1.printLoggingGrepHelper)(constants_1.ServerlessRoutines.compositions, {
+                isWarm,
+            }, params.logLevel);
+        }
+        const response = await (0, compositions_1.compositionsHandler)({
+            params,
+            options: {
+                expectedBucketOwner: currentUserId,
+            },
+            providerSpecifics,
+            insideFunctionSpecifics,
+        });
+        await responseWriter.write(Buffer.from(JSON.stringify(response)));
+        await responseWriter.end();
+        return;
+    }
+    throw new Error(constants_1.COMMAND_NOT_FOUND);
+};
+exports.innerHandler = innerHandler;
+const innerRoutine = async ({ params, responseWriter, context, providerSpecifics, insideFunctionSpecifics, webhookClient, }) => {
+    try {
+        await (0, exports.innerHandler)({
+            params,
+            responseWriter,
+            context,
+            providerSpecifics,
+            insideFunctionSpecifics,
+            webhookClient,
+        });
+    }
+    catch (err) {
+        const res = {
+            type: 'error',
+            message: err.message,
+            stack: err.stack,
+        };
+        await responseWriter.write(Buffer.from(JSON.stringify(res)));
+        await responseWriter.end();
+    }
+};
+exports.innerRoutine = innerRoutine;

package/dist/inspect-error.d.ts

@@ -1,4 +1,4 @@
-import type { EnhancedErrorInfo, LambdaErrorInfo } from './write-lambda-error';
+import type { EnhancedErrorInfo, FunctionErrorInfo } from './write-error-to-storage';
 export declare const inspectErrors: ({ errors, }: {
-    errors: LambdaErrorInfo[];
+    errors: FunctionErrorInfo[];
 }) => EnhancedErrorInfo[];

package/dist/invoke-webhook.d.ts

@@ -2,32 +2,35 @@ import type { LogLevel } from '@remotion/renderer';
 import type https from 'https';
 import type http from 'node:http';
 import type { AfterRenderCost } from './constants';
-import type { EnhancedErrorInfo } from './write-lambda-error';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
 export declare function calculateSignature(payload: string, secret: string | null): string;
-type DynamicWebhookPayload = {
+type StaticWebhookPayload = {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+    customData: Record<string, unknown> | null;
+};
+export type WebhookErrorPayload = StaticWebhookPayload & {
     type: 'error';
     errors: {
         message: string;
         name: string;
         stack: string;
     }[];
-} | {
+};
+export type WebhookSuccessPayload = StaticWebhookPayload & {
     type: 'success';
     lambdaErrors: EnhancedErrorInfo[];
     outputUrl: string | undefined;
     outputFile: string | undefined;
     timeToFinish: number | undefined;
     costs: AfterRenderCost;
-} | {
+};
+export type WebhookTimeoutPayload = StaticWebhookPayload & {
     type: 'timeout';
 };
-export type WebhookPayload = {
-    renderId: string;
-    expectedBucketOwner: string;
-    bucketName: string;
-    customData: Record<string, unknown> | null;
-} & DynamicWebhookPayload;
-export type WebhookClient = (url: string | URL, options: https.RequestOptions, callback?: (res: http.IncomingMessage) => void) => http.ClientRequest;
+export type WebhookPayload = WebhookErrorPayload | WebhookSuccessPayload | WebhookTimeoutPayload;
+export type WebhookClient = (url: string) => (url: string | URL, options: https.RequestOptions, callback?: (res: http.IncomingMessage) => void) => http.ClientRequest;
 type InvokeWebhookOptions = {
     payload: WebhookPayload;
     url: string;

package/dist/invoke-webhook.js

@@ -41,7 +41,7 @@ const redirectStatusCodes = [301, 302, 303, 307, 308];
 function invokeWebhookRaw({ payload, secret, url, redirectsSoFar, client, }) {
     const jsonPayload = JSON.stringify(payload);
     return new Promise((resolve, reject) => {
-        const req = client(url, {
+        const req = client(url)(url, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',

package/dist/is-warm.d.ts

@@ -0,0 +1,2 @@
+export declare const setWarm: () => void;
+export declare const getWarm: () => boolean;

package/dist/is-warm.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWarm = exports.setWarm = void 0;
+let warm = false;
+const setWarm = () => {
+    warm = true;
+};
+exports.setWarm = setWarm;
+const getWarm = () => warm;
+exports.getWarm = getWarm;

package/dist/make-bucket-name.d.ts

@@ -1,3 +1,3 @@
 import type { ProviderSpecifics } from './provider-implementation';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 export declare const makeBucketName: <Provider extends CloudProvider>(region: Provider["region"], providerSpecifics: ProviderSpecifics<Provider>) => string;

package/dist/make-timeout-error.d.ts

@@ -1,7 +1,7 @@
 import type { ProviderSpecifics } from './provider-implementation';
 import type { RenderMetadata } from './render-metadata';
 import type { CloudProvider } from './types';
-import type { EnhancedErrorInfo } from './write-lambda-error';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
 export declare const makeTimeoutError: <Provider extends CloudProvider>({ timeoutInMilliseconds, missingChunks, renderMetadata, renderId, functionName, region, providerSpecifics, }: {
     timeoutInMilliseconds: number;
     renderMetadata: RenderMetadata<Provider>;

package/dist/make-timeout-message.js

@@ -4,7 +4,7 @@ exports.makeTimeoutMessage = void 0;
 const constants_1 = require("./constants");
 const docs_url_1 = require("./docs-url");
 const MAX_MISSING_CHUNKS = 5;
-const makeChunkMissingMessage = ({ missingChunks, renderMetadata, region, providerSpecifics, }) => {
+const makeChunkMissingMessage = ({ missingChunks, renderMetadata, region, providerSpecifics, functionName, }) => {
     if (missingChunks.length === 0) {
         return 'All chunks have been successfully rendered, but the main function has timed out.';
     }
@@ -23,7 +23,7 @@ const makeChunkMissingMessage = ({ missingChunks, renderMetadata, region, provid
             return [
                 msg,
                 `▸ Logs for chunk ${ch}: ${providerSpecifics.getLoggingUrlForRendererFunction({
-                    functionName: providerSpecifics.getCurrentFunctionName(),
+                    functionName,
                     region,
                     rendererFunctionName: null,
                     renderId: renderMetadata.renderId,
@@ -56,6 +56,7 @@ const makeTimeoutMessage = ({ timeoutInMilliseconds, missingChunks, renderMetada
             renderMetadata,
             region,
             providerSpecifics,
+            functionName,
         }),
         '',
         `Consider increasing the timeout of your function.`,

package/dist/merge-chunks.d.ts

@@ -1,7 +1,7 @@
 import type { AudioCodec, LogLevel } from '@remotion/renderer';
 import type { CustomCredentials, DownloadBehavior, PostRenderData, Privacy, SerializedInputProps, ServerlessCodec } from './constants';
 import type { OverallProgressHelper } from './overall-render-progress';
-import type { ProviderSpecifics } from './provider-implementation';
+import type { InsideFunctionSpecifics, ProviderSpecifics } from './provider-implementation';
 import type { RenderMetadata } from './render-metadata';
 import type { CloudProvider } from './types';
 export declare const mergeChunksAndFinishRender: <Provider extends CloudProvider>(options: {
@@ -33,5 +33,6 @@ export declare const mergeChunksAndFinishRender: <Provider extends CloudProvider
     overallProgress: OverallProgressHelper<Provider>;
     startTime: number;
     providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
     forcePathStyle: boolean;
 }) => Promise<PostRenderData<Provider>>;

package/dist/merge-chunks.js

@@ -37,12 +37,12 @@ const mergeChunksAndFinishRender = async (options) => {
         preferLossless: options.preferLossless,
         muted: options.renderMetadata.muted,
         metadata: options.renderMetadata.metadata,
-        providerSpecifics: options.providerSpecifics,
+        insideFunctionSpecifics: options.insideFunctionSpecifics,
     });
     const encodingStop = Date.now();
     options.overallProgress.setTimeToCombine(encodingStop - encodingStart);
     const outputSize = fs_1.default.statSync(outfile).size;
-    const writeToBucket = options.providerSpecifics.timer(`Writing to bucket (${outputSize} bytes)`, options.logLevel);
+    const writeToBucket = options.insideFunctionSpecifics.timer(`Writing to bucket (${outputSize} bytes)`, options.logLevel);
     await options.providerSpecifics.writeFile({
         bucketName: options.renderBucketName,
         key: options.key,
@@ -72,7 +72,7 @@ const mergeChunksAndFinishRender = async (options) => {
     });
     const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
         region: options.providerSpecifics.getCurrentRegionInFunction(),
-        memorySizeInMb: Number(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE),
+        memorySizeInMb: options.insideFunctionSpecifics.getCurrentMemorySizeInMb(),
         renderMetadata: options.renderMetadata,
         errorExplanations,
         timeToDelete: (await cleanupProm).reduce((a, b) => Math.max(a, b), 0),

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

@@ -5,9 +5,9 @@ export type ExpensiveChunk = {
     frameRange: [number, number];
     timeInMilliseconds: number;
 };
-export declare const getMostExpensiveChunks: ({ parsedTimings, framesPerLambda, firstFrame, lastFrame, }: {
+export declare const getMostExpensiveChunks: ({ parsedTimings, framesPerFunction: framesPerLambda, firstFrame, lastFrame, }: {
     parsedTimings: ParsedTiming[];
-    framesPerLambda: number;
+    framesPerFunction: number;
     firstFrame: number;
     lastFrame: number;
 }) => ExpensiveChunk[];

package/dist/most-expensive-chunks.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMostExpensiveChunks = exports.OVERHEAD_TIME_PER_LAMBDA = void 0;
 exports.OVERHEAD_TIME_PER_LAMBDA = 100;
-const getMostExpensiveChunks = ({ parsedTimings, framesPerLambda, firstFrame, lastFrame, }) => {
+const getMostExpensiveChunks = ({ parsedTimings, framesPerFunction: framesPerLambda, firstFrame, lastFrame, }) => {
     const mostExpensiveChunks = parsedTimings
         .slice(0)
         .sort((a, b) => {

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

@@ -3,7 +3,7 @@ import type { PostRenderData } from './constants';
 import type { ProviderSpecifics } from './provider-implementation';
 import type { RenderMetadata } from './render-metadata';
 import type { ChunkRetry, CloudProvider, ParsedTiming, ReceivedArtifact } from './types';
-import type { LambdaErrorInfo } from './write-lambda-error';
+import type { FunctionErrorInfo } from './write-error-to-storage';
 export type OverallRenderProgress<Provider extends CloudProvider> = {
     chunks: number[];
     framesRendered: number;
@@ -17,7 +17,7 @@ export type OverallRenderProgress<Provider extends CloudProvider> = {
     postRenderData: PostRenderData<Provider> | null;
     timings: ParsedTiming[];
     renderMetadata: RenderMetadata<Provider> | null;
-    errors: LambdaErrorInfo[];
+    errors: FunctionErrorInfo[];
     timeoutTimestamp: number;
     functionLaunched: number;
     serveUrlOpened: number | null;
@@ -38,7 +38,7 @@ export type OverallProgressHelper<Provider extends CloudProvider> = {
     addRetry: (retry: ChunkRetry) => void;
     setPostRenderData: (postRenderData: PostRenderData<Provider>) => void;
     setRenderMetadata: (renderMetadata: RenderMetadata<Provider>) => void;
-    addErrorWithoutUpload: (errorInfo: LambdaErrorInfo) => void;
+    addErrorWithoutUpload: (errorInfo: FunctionErrorInfo) => void;
     setExpectedChunks: (expectedChunks: number) => void;
     get: () => OverallRenderProgress<Provider>;
     setServeUrlOpened: (timestamp: number) => void;

package/dist/plan-frame-ranges.d.ts

@@ -1,5 +1,5 @@
-export declare const planFrameRanges: ({ framesPerLambda, frameRange, everyNthFrame, }: {
-    framesPerLambda: number;
+export declare const planFrameRanges: ({ framesPerFunction, frameRange, everyNthFrame, }: {
+    framesPerFunction: number;
     frameRange: [number, number];
     everyNthFrame: number;
 }) => {

package/dist/plan-frame-ranges.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.planFrameRanges = void 0;
 const renderer_1 = require("@remotion/renderer");
-const planFrameRanges = ({ framesPerLambda, frameRange, everyNthFrame, }) => {
+const planFrameRanges = ({ framesPerFunction, frameRange, everyNthFrame, }) => {
     const framesToRender = renderer_1.RenderInternals.getFramesToRender(frameRange, everyNthFrame);
-    const chunkCount = Math.ceil(framesToRender.length / framesPerLambda);
+    const chunkCount = Math.ceil(framesToRender.length / framesPerFunction);
     const firstFrame = frameRange[0];
     return {
         chunks: new Array(chunkCount).fill(1).map((_, i) => {
-            const start = i * framesPerLambda * everyNthFrame + firstFrame;
-            const end = Math.min(framesToRender[framesToRender.length - 1], (i + 1) * framesPerLambda * everyNthFrame - 1 + firstFrame);
+            const start = i * framesPerFunction * everyNthFrame + firstFrame;
+            const end = Math.min(framesToRender[framesToRender.length - 1], (i + 1) * framesPerFunction * everyNthFrame - 1 + firstFrame);
             return [start, end];
         }),
     };

package/dist/print-logging-grep-helper.d.ts

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

package/dist/print-logging-grep-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/progress.js

@@ -145,10 +145,10 @@ const getProgress = async ({ bucketName, renderId, expectedBucketOwner, region,
             artifacts: overallProgress.receivedArtifact,
         };
     }
-    const priceFromBucket = (0, estimate_price_from_bucket_1.estimatePriceFromBucket)({
+    const priceFromBucket = (0, estimate_price_from_bucket_1.estimatePriceFromMetadata)({
         renderMetadata,
         memorySizeInMb,
-        lambdasInvoked: (_h = renderMetadata.estimatedRenderLambdaInvokations) !== null && _h !== void 0 ? _h : 0,
+        functionsInvoked: (_h = renderMetadata.estimatedRenderLambdaInvokations) !== null && _h !== void 0 ? _h : 0,
         diskSizeInMb: providerSpecifics.getEphemeralStorageForPriceCalculation(),
         timings: (_j = overallProgress.timings) !== null && _j !== void 0 ? _j : [],
         region,