@remotion/serverless 4.0.245 → 4.0.246

package/dist/provider-implementation.d.ts

@@ -1,8 +1,13 @@
-import type { EmittedArtifact } from '@remotion/renderer';
+import type { bundle } from '@remotion/bundler';
+import type { ChromiumOptions, EmittedArtifact, LogLevel } from '@remotion/renderer';
 import type { Readable } from 'stream';
-import type { CustomCredentials, DownloadBehavior, Privacy } from './constants';
+import type { CustomCredentials, DeleteAfter, DownloadBehavior, Privacy, ServerlessRoutines } from './constants';
+import type { LaunchedBrowser } from './get-browser-instance';
 import type { GetFolderFiles } from './get-files-in-folder';
-import type { CloudProvider, ReceivedArtifact } from './still';
+import type { RenderMetadata } from './render-metadata';
+import type { ServerlessReturnValues } from './return-values';
+import type { OnMessage } from './streaming/streaming';
+import type { CallFunctionOptions, CloudProvider, ReceivedArtifact } from './types';
 export type BucketWithLocation<Provider extends CloudProvider> = {
     name: string;
     creationDate: number;
@@ -96,6 +101,134 @@ export type MakeArtifactWithDetails<Provider extends CloudProvider> = (params: {
     storageKey: string;
     artifact: EmittedArtifact;
 }) => ReceivedArtifact<Provider>;
+export type DebuggingTimer = (label: string, logLevel: LogLevel) => {
+    end: () => void;
+};
+export type CallFunctionAsync<Provider extends CloudProvider> = <T extends ServerlessRoutines>({ functionName, payload, region, timeoutInTest, }: 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 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 GetLoggingUrlForMethod<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+    functionName: string;
+    method: ServerlessRoutines;
+    rendererFunctionName: string | null;
+    renderId: string;
+}) => string;
+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 GetBrowserInstance = <Provider extends CloudProvider>({ logLevel, indent, chromiumOptions, providerSpecifics, insideFunctionSpecifics, }: {
+    logLevel: LogLevel;
+    indent: boolean;
+    chromiumOptions: ChromiumOptions;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics;
+}) => Promise<LaunchedBrowser>;
+export type ForgetBrowserEventLoop = (logLevel: LogLevel) => void;
+export type GenerateRenderId = (options: {
+    deleteAfter: DeleteAfter | null;
+    randomHashFn: () => string;
+}) => string;
+export type GetAccountId<Provider extends CloudProvider> = (options: {
+    region: Provider['region'];
+}) => Promise<string>;
+export type DeleteFunctionInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    functionName: string;
+};
+export type DeleteFunction<Provider extends CloudProvider> = (options: DeleteFunctionInput<Provider>) => Promise<void>;
+export type GetFunctionsInput<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    compatibleOnly: boolean;
+    logLevel?: LogLevel;
+};
+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 ReadDir = ({ dir, etags, originalDir, onProgress, }: {
+    dir: string;
+    etags: {
+        [key: string]: () => Promise<string>;
+    };
+    originalDir: string;
+    onProgress: (bytes: number) => void;
+}) => {
+    [key: string]: () => Promise<string>;
+};
+export type UploadDirProgress = {
+    totalFiles: number;
+    filesUploaded: number;
+    totalSize: number;
+    sizeUploaded: number;
+};
+export type UploadDir<Provider extends CloudProvider> = (options: {
+    bucket: string;
+    region: Provider['region'];
+    localDir: string;
+    keyPrefix: string;
+    onProgress: (progress: UploadDirProgress) => void;
+    privacy: Privacy;
+    toUpload: string[];
+    forcePathStyle: boolean;
+}) => Promise<void>;
+type CreateFunctionOptions<Provider extends CloudProvider> = {
+    region: Provider['region'];
+    logLevel: LogLevel;
+    ephemerealStorageInMb: number;
+    timeoutInSeconds: number;
+    memorySizeInMb: number;
+    functionName: string;
+    zipFile: string;
+} & Provider['creationFunctionOptions'];
+export type CreateFunction<Provider extends CloudProvider> = (options: CreateFunctionOptions<Provider>) => Promise<{
+    FunctionName: string;
+}>;
+export type InsideFunctionSpecifics = {
+    getBrowserInstance: GetBrowserInstance;
+    forgetBrowserEventLoop: ForgetBrowserEventLoop;
+    timer: DebuggingTimer;
+    generateRandomId: GenerateRenderId;
+    deleteTmpDir: () => Promise<void>;
+    getCurrentFunctionName: () => string;
+    getCurrentMemorySizeInMb: () => number;
+};
+export type FullClientSpecifics<Provider extends CloudProvider> = {
+    id: '__remotion_full_client_specifics';
+    bundleSite: typeof bundle;
+    readDirectory: ReadDir;
+    uploadDir: UploadDir<Provider>;
+    createFunction: CreateFunction<Provider>;
+    checkCredentials: () => void;
+};
 export type ProviderSpecifics<Provider extends CloudProvider> = {
     getChromiumPath: () => string | null;
     getCurrentRegionInFunction: () => Provider['region'];
@@ -113,5 +246,21 @@ export type ProviderSpecifics<Provider extends CloudProvider> = {
     printLoggingHelper: boolean;
     getFolderFiles: GetFolderFiles;
     makeArtifactWithDetails: MakeArtifactWithDetails<Provider>;
+    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>;
 };
 export {};

package/dist/render-metadata.d.ts

@@ -1,6 +1,6 @@
 import type { AudioCodec, DeleteAfter, StillImageFormat, VideoImageFormat } from '@remotion/renderer';
 import type { DownloadBehavior, OutNameInputWithoutCredentials, Privacy, SerializedInputProps, ServerlessCodec } from './constants';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 type Discriminated = {
     type: 'still';
     imageFormat: StillImageFormat;

package/dist/render-progress.d.ts

@@ -1,7 +1,7 @@
 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-lambda-error';
+import type { EnhancedErrorInfo } from './write-error-to-storage';
 export type CleanupInfo = {
     doneIn: number | null;
     minFilesToDelete: number;

package/dist/streaming/streaming.d.ts

@@ -1,6 +1,6 @@
 import type { SerializedArtifact } from '../serialize-artifact';
-import type { CloudProvider, RenderStillLambdaResponsePayload } from '../still';
-import type { LambdaErrorInfo } from '../write-lambda-error';
+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";
@@ -8,7 +8,7 @@ declare const videoChunkRendered: "video-chunk-rendered";
 declare const audioChunkRendered: "audio-chunk-rendered";
 declare const chunkComplete: "chunk-complete";
 declare const stillRendered: "still-rendered";
-declare const lambdaInvoked: "lambda-invoked";
+declare const functionInvoked: "lambda-invoked";
 declare const artifactEmitted: "artifact-emitted";
 declare const messageTypes: {
     readonly '1': {
@@ -61,7 +61,7 @@ export type StreamingPayload<Provider extends CloudProvider> = {
     payload: {
         error: string;
         shouldRetry: boolean;
-        errorInfo: LambdaErrorInfo;
+        errorInfo: FunctionErrorInfo;
     };
 } | {
     type: typeof renderIdDetermined;
@@ -70,7 +70,7 @@ export type StreamingPayload<Provider extends CloudProvider> = {
     };
 } | {
     type: typeof stillRendered;
-    payload: RenderStillLambdaResponsePayload<Provider>;
+    payload: RenderStillFunctionResponsePayload<Provider>;
 } | {
     type: typeof chunkComplete;
     payload: {
@@ -78,7 +78,7 @@ export type StreamingPayload<Provider extends CloudProvider> = {
         rendered: number;
     };
 } | {
-    type: typeof lambdaInvoked;
+    type: typeof functionInvoked;
     payload: {
         attempt: number;
     };

package/dist/streaming/streaming.js

@@ -9,7 +9,7 @@ const videoChunkRendered = 'video-chunk-rendered';
 const audioChunkRendered = 'audio-chunk-rendered';
 const chunkComplete = 'chunk-complete';
 const stillRendered = 'still-rendered';
-const lambdaInvoked = 'lambda-invoked';
+const functionInvoked = 'lambda-invoked';
 const artifactEmitted = 'artifact-emitted';
 const messageTypes = {
     '1': { type: framesRendered },
@@ -19,7 +19,7 @@ const messageTypes = {
     '5': { type: audioChunkRendered },
     '6': { type: stillRendered },
     '7': { type: chunkComplete },
-    '8': { type: lambdaInvoked },
+    '8': { type: functionInvoked },
     '9': { type: artifactEmitted },
 };
 exports.formatMap = {
@@ -30,7 +30,7 @@ exports.formatMap = {
     [audioChunkRendered]: 'binary',
     [stillRendered]: 'json',
     [chunkComplete]: 'json',
-    [lambdaInvoked]: 'json',
+    [functionInvoked]: 'json',
     [artifactEmitted]: 'json',
 };
 const messageTypeIdToMessageType = (messageTypeId) => {

package/dist/types.d.ts

@@ -1,8 +1,9 @@
 import type { ServerlessPayloads, ServerlessRoutines } from './constants';
-export interface CloudProvider<Region extends string = string, ReceivedArtifactType extends Record<string, unknown> = Record<string, unknown>> {
+export interface CloudProvider<Region extends string = string, ReceivedArtifactType extends Record<string, unknown> = Record<string, unknown>, CreateFunctionSpecifics extends Record<string, unknown> = Record<string, unknown>> {
     type: string;
     region: Region;
     receivedArtifactType: ReceivedArtifactType;
+    creationFunctionOptions: CreateFunctionSpecifics;
 }
 export type ReceivedArtifact<Provider extends CloudProvider> = {
     filename: string;
@@ -16,7 +17,7 @@ export type CostsInfo = {
     currency: string;
     disclaimer: string;
 };
-export type RenderStillLambdaResponsePayload<Provider extends CloudProvider> = {
+export type RenderStillFunctionResponsePayload<Provider extends CloudProvider> = {
     type: 'success';
     output: string;
     outKey: string;

package/dist/validate-composition.d.ts

@@ -2,7 +2,7 @@ import type { ChromiumOptions, LogLevel, OnBrowserDownload, openBrowser, Remotio
 import type { VideoConfig } from 'remotion/no-react';
 import type { Await } from './await';
 import type { ProviderSpecifics } from './provider-implementation';
-import type { CloudProvider } from './still';
+import type { CloudProvider } from './types';
 type ValidateCompositionOptions<Provider extends CloudProvider> = {
     serveUrl: string;
     composition: string;

package/dist/validate-composition.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateComposition = void 0;
 const renderer_1 = require("@remotion/renderer");
+const validate_1 = require("./validate");
 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,
@@ -22,10 +23,19 @@ const validateComposition = async ({ serveUrl, composition, browserInstance, ser
         onBrowserDownload,
         onServeUrlVisited,
     });
-    return {
+    const videoConfig = {
         ...comp,
         height: forceHeight !== null && forceHeight !== void 0 ? forceHeight : comp.height,
         width: forceWidth !== null && forceWidth !== void 0 ? forceWidth : comp.width,
     };
+    const reason = `of the "<Composition />" component with the id "${composition}"`;
+    (0, validate_1.validateDurationInFrames)(comp.durationInFrames, {
+        component: reason,
+        allowFloats: false,
+    });
+    (0, validate_1.validateFps)(comp.fps, reason, false);
+    (0, validate_1.validateDimension)(comp.height, 'height', reason);
+    (0, validate_1.validateDimension)(comp.width, 'width', reason);
+    return videoConfig;
 };
 exports.validateComposition = validateComposition;

package/dist/validate-frames-per-function.d.ts

@@ -1,4 +1,4 @@
-export declare const validateFramesPerFunction: ({ framesPerLambda, durationInFrames, }: {
-    framesPerLambda: unknown;
+export declare const validateFramesPerFunction: ({ framesPerFunction, durationInFrames, }: {
+    framesPerFunction: unknown;
     durationInFrames: number;
 }) => void;

package/dist/validate-frames-per-function.js

@@ -2,28 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateFramesPerFunction = void 0;
 const constants_1 = require("./constants");
-const validateFramesPerFunction = ({ framesPerLambda, durationInFrames, }) => {
-    if (framesPerLambda === null) {
+const validateFramesPerFunction = ({ framesPerFunction, durationInFrames, }) => {
+    if (framesPerFunction === null) {
         return;
     }
-    if (framesPerLambda === undefined) {
+    if (framesPerFunction === undefined) {
         return;
     }
-    if (typeof framesPerLambda !== 'number') {
-        throw new TypeError(`'framesPerLambda' needs to be a number, passed ${JSON.stringify(framesPerLambda)}`);
+    if (typeof framesPerFunction !== 'number') {
+        throw new TypeError(`'framesPerLambda' needs to be a number, passed ${JSON.stringify(framesPerFunction)}`);
     }
-    if (!Number.isFinite(framesPerLambda)) {
-        throw new TypeError(`'framesPerLambda' needs to be finite, passed ${framesPerLambda}`);
+    if (!Number.isFinite(framesPerFunction)) {
+        throw new TypeError(`'framesPerLambda' needs to be finite, passed ${framesPerFunction}`);
     }
-    if (Number.isNaN(framesPerLambda)) {
-        throw new TypeError(`'framesPerLambda' needs to be NaN, passed ${framesPerLambda}`);
+    if (Number.isNaN(framesPerFunction)) {
+        throw new TypeError(`'framesPerLambda' needs to be NaN, passed ${framesPerFunction}`);
     }
-    if (framesPerLambda % 1 !== 0) {
-        throw new TypeError(`'framesPerLambda' needs to be an integer, passed ${framesPerLambda}`);
+    if (framesPerFunction % 1 !== 0) {
+        throw new TypeError(`'framesPerLambda' needs to be an integer, passed ${framesPerFunction}`);
     }
     const effectiveMinimum = Math.min(constants_1.MINIMUM_FRAMES_PER_LAMBDA, durationInFrames);
-    if (framesPerLambda < effectiveMinimum) {
-        throw new TypeError(`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerLambda}`);
+    if (framesPerFunction < effectiveMinimum) {
+        throw new TypeError(`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerFunction}`);
     }
 };
 exports.validateFramesPerFunction = validateFramesPerFunction;

package/dist/{write-lambda-error.d.ts → write-error-to-storage.d.ts}

@@ -1,7 +1,7 @@
 import type { FileNameAndSize } from './get-files-in-folder';
 import type { ProviderSpecifics } from './provider-implementation';
-import type { CloudProvider } from './still';
-export type LambdaErrorInfo = {
+import type { CloudProvider } from './types';
+export type FunctionErrorInfo = {
     type: 'renderer' | 'browser' | 'stitcher' | 'webhook' | 'artifact';
     message: string;
     name: string;
@@ -17,8 +17,8 @@ export type LambdaErrorInfo = {
         total: number;
     } | null;
 };
-export declare const getTmpDirStateIfENoSp: <Provider extends CloudProvider>(err: string, providerSpecifics: ProviderSpecifics<Provider>) => LambdaErrorInfo["tmpDir"];
-export type EnhancedErrorInfo = LambdaErrorInfo & {
+export declare const getTmpDirStateIfENoSp: <Provider extends CloudProvider>(err: string, providerSpecifics: ProviderSpecifics<Provider>) => FunctionErrorInfo["tmpDir"];
+export type EnhancedErrorInfo = FunctionErrorInfo & {
     /**
      * @deprecated Will always be an empty string.
      */

package/package.json

@@ -3,7 +3,7 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/serverless"
   },
   "name": "@remotion/serverless",
-  "version": "4.0.245",
+  "version": "4.0.246",
   "description": "A runtime for distributed rendering",
   "main": "dist",
   "sideEffects": false,
@@ -17,13 +17,14 @@
     "access": "public"
   },
   "dependencies": {
-    "remotion": "4.0.245",
-    "@remotion/renderer": "4.0.245",
-    "@remotion/streaming": "4.0.245"
+    "remotion": "4.0.246",
+    "@remotion/renderer": "4.0.246",
+    "@remotion/bundler": "4.0.246",
+    "@remotion/streaming": "4.0.246"
   },
   "devDependencies": {
     "eslint": "9.14.0",
-    "@remotion/eslint-config-internal": "4.0.245"
+    "@remotion/eslint-config-internal": "4.0.246"
   },
   "exports": {
     ".": "./dist/index.js",