@remotion/serverless 4.0.244 → 4.0.246

package/dist/stream-renderer.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamRendererFunctionWithRetry = void 0;
+const renderer_1 = require("@remotion/renderer");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const constants_1 = require("./constants");
+const serialize_artifact_1 = require("./serialize-artifact");
+const streamRenderer = ({ payload, functionName, outdir, overallProgress, files, logLevel, onArtifact, providerSpecifics, }) => {
+    if (payload.type !== constants_1.ServerlessRoutines.renderer) {
+        throw new Error('Expected renderer type');
+    }
+    return new Promise((resolve) => {
+        const receivedStreamingPayload = ({ message }) => {
+            if (message.type === 'lambda-invoked') {
+                overallProgress.setLambdaInvoked(payload.chunk);
+                return;
+            }
+            if (message.type === 'frames-rendered') {
+                overallProgress.setFrames({
+                    index: payload.chunk,
+                    encoded: message.payload.encoded,
+                    rendered: message.payload.rendered,
+                });
+                return;
+            }
+            if (message.type === 'video-chunk-rendered') {
+                const filename = (0, path_1.join)(outdir, `chunk:${String(payload.chunk).padStart(8, '0')}:video`);
+                (0, fs_1.writeFileSync)(filename, message.payload);
+                files.push(filename);
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Received video chunk for chunk ${payload.chunk}`);
+                return;
+            }
+            if (message.type === 'audio-chunk-rendered') {
+                const filename = (0, path_1.join)(outdir, `chunk:${String(payload.chunk).padStart(8, '0')}:audio`);
+                (0, fs_1.writeFileSync)(filename, message.payload);
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Received audio chunk for chunk ${payload.chunk}`);
+                files.push(filename);
+                return;
+            }
+            if (message.type === 'chunk-complete') {
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `Finished chunk ${payload.chunk}`);
+                overallProgress.addChunkCompleted(payload.chunk, message.payload.start, message.payload.rendered);
+                return;
+            }
+            if (message.type === 'artifact-emitted') {
+                const artifact = (0, serialize_artifact_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) {
+                    return resolve({
+                        type: 'error',
+                        error: `Chunk ${payload.chunk} emitted an asset filename ${message.payload.artifact.filename} at frame ${message.payload.artifact.frame} but there is already another artifact with the same name. https://remotion.dev/docs/artifacts`,
+                        shouldRetry: false,
+                    });
+                }
+                return;
+            }
+            if (message.type === 'error-occurred') {
+                overallProgress.addErrorWithoutUpload(message.payload.errorInfo);
+                overallProgress.setFrames({
+                    encoded: 0,
+                    index: payload.chunk,
+                    rendered: 0,
+                });
+                renderer_1.RenderInternals.Log.error({
+                    indent: false,
+                    logLevel,
+                }, `Renderer function of chunk ${payload.chunk} failed with error: ${message.payload.error}`);
+                renderer_1.RenderInternals.Log.error({
+                    indent: false,
+                    logLevel,
+                }, `Will retry chunk = ${message.payload.shouldRetry}`);
+                resolve({
+                    type: 'error',
+                    error: message.payload.error,
+                    shouldRetry: message.payload.shouldRetry,
+                });
+                return;
+            }
+            throw new Error(`Unknown message type ${message.type}`);
+        };
+        providerSpecifics
+            .callFunctionStreaming({
+            functionName,
+            payload,
+            retriesRemaining: 1,
+            region: providerSpecifics.getCurrentRegionInFunction(),
+            timeoutInTest: 12000,
+            type: constants_1.ServerlessRoutines.renderer,
+            receivedStreamingPayload,
+        })
+            .then(() => {
+            resolve({
+                type: 'success',
+            });
+        })
+            .catch((err) => {
+            var _a, _b;
+            const shouldRetry = (_b = (_a = err.stack) === null || _a === void 0 ? void 0 : _a.includes('Error: aborted')) !== null && _b !== void 0 ? _b : false;
+            resolve({
+                type: 'error',
+                error: err.stack,
+                shouldRetry,
+            });
+        });
+    });
+};
+const streamRendererFunctionWithRetry = async ({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, }) => {
+    if (payload.type !== constants_1.ServerlessRoutines.renderer) {
+        throw new Error('Expected renderer type');
+    }
+    const result = await streamRenderer({
+        files,
+        functionName,
+        outdir,
+        overallProgress,
+        payload,
+        logLevel,
+        onArtifact,
+        providerSpecifics,
+    });
+    if (result.type === 'error') {
+        if (!result.shouldRetry) {
+            throw new Error(result.error);
+        }
+        overallProgress.addRetry({
+            attempt: payload.attempt + 1,
+            time: Date.now(),
+            chunk: payload.chunk,
+        });
+        return (0, exports.streamRendererFunctionWithRetry)({
+            files,
+            functionName,
+            outdir,
+            overallProgress,
+            payload: {
+                ...payload,
+                attempt: payload.attempt + 1,
+                retriesLeft: payload.retriesLeft - 1,
+            },
+            logLevel,
+            onArtifact,
+            providerSpecifics,
+        });
+    }
+};
+exports.streamRendererFunctionWithRetry = streamRendererFunctionWithRetry;

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

@@ -0,0 +1,55 @@
+import type { ServerlessPayloads, ServerlessRoutines } from './constants';
+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;
+    sizeInBytes: number;
+    s3Url: string;
+    s3Key: string;
+} & Provider['receivedArtifactType'];
+export type CostsInfo = {
+    accruedSoFar: number;
+    displayCost: string;
+    currency: string;
+    disclaimer: string;
+};
+export type RenderStillFunctionResponsePayload<Provider extends CloudProvider> = {
+    type: 'success';
+    output: string;
+    outKey: string;
+    size: number;
+    bucketName: string;
+    sizeInBytes: number;
+    estimatedPrice: CostsInfo;
+    renderId: string;
+    receivedArtifacts: ReceivedArtifact<Provider>[];
+};
+export type ChunkRetry = {
+    chunk: number;
+    attempt: number;
+    time: number;
+};
+export type ParsedTiming = {
+    chunk: number;
+    start: number;
+    rendered: number;
+};
+export type CallFunctionOptions<T extends ServerlessRoutines, Provider extends CloudProvider> = {
+    functionName: string;
+    type: T;
+    payload: ServerlessPayloads<Provider>[T];
+    region: Provider['region'];
+    timeoutInTest: number;
+};
+export type ObjectChunkTimingData = {
+    chunk: number;
+    frameRange: [number, number];
+    startDate: number;
+    timings: {
+        [key: number]: number;
+    };
+};

package/dist/types.js

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

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-download-behavior.d.ts

@@ -0,0 +1 @@
+export declare const validateDownloadBehavior: (downloadBehavior: unknown) => null | undefined;

package/dist/validate-download-behavior.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDownloadBehavior = void 0;
+const validateDownloadBehavior = (downloadBehavior) => {
+    if (downloadBehavior === null || downloadBehavior === undefined) {
+        return null;
+    }
+    if (typeof downloadBehavior !== 'object') {
+        throw new Error('downloadBehavior must be null or an object');
+    }
+    const behavior = downloadBehavior;
+    if (behavior.type !== 'download' && behavior.type !== 'play-in-browser') {
+        throw new Error('Download behavior must be either "download" or "play-in-browser"');
+    }
+    if (behavior.type === 'download') {
+        if (typeof behavior.fileName !== 'string' && behavior.fileName !== null) {
+            throw new Error('If "downloadBehavior.type" is "download", then fileName must be "null" or a string');
+        }
+    }
+};
+exports.validateDownloadBehavior = validateDownloadBehavior;

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

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

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

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

package/dist/validate-privacy.d.ts

@@ -0,0 +1,2 @@
+import type { Privacy } from './constants';
+export declare function validatePrivacy(privacy: unknown, allowPrivate: boolean): asserts privacy is Privacy;

package/dist/validate-privacy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePrivacy = validatePrivacy;
+function validatePrivacy(privacy, allowPrivate) {
+    if (typeof privacy !== 'string') {
+        throw new TypeError('Privacy must be a string');
+    }
+    if (!allowPrivate && privacy === 'private') {
+        throw new TypeError('Privacy must be either "public" or "no-acl"');
+    }
+    if (privacy !== 'private' && privacy !== 'public' && privacy !== 'no-acl') {
+        throw new TypeError('Privacy must be either "private", "public" or "no-acl"');
+    }
+}

package/dist/validate.d.ts

@@ -0,0 +1,4 @@
+import { NoReactInternals } from 'remotion/no-react';
+export declare const validateFps: typeof NoReactInternals.validateFps;
+export declare const validateDimension: typeof NoReactInternals.validateDimension;
+export declare const validateDurationInFrames: typeof NoReactInternals.validateDurationInFrames;

package/dist/validate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDurationInFrames = exports.validateDimension = exports.validateFps = void 0;
+/* eslint-disable prefer-destructuring */
+const no_react_1 = require("remotion/no-react");
+exports.validateFps = no_react_1.NoReactInternals.validateFps;
+exports.validateDimension = no_react_1.NoReactInternals.validateDimension;
+exports.validateDurationInFrames = no_react_1.NoReactInternals.validateDurationInFrames;

package/dist/why-is-node-running.d.ts

@@ -0,0 +1,15 @@
+import asyncHooks from 'async_hooks';
+type Resource = {
+    type: string;
+    stacks: NodeJS.CallSite[];
+    resource: {
+        hasRef?: () => boolean;
+    };
+};
+export type NodeIntrospection = {
+    hook: asyncHooks.AsyncHook | null;
+    active: Map<number, Resource>;
+};
+export declare const enableNodeIntrospection: (enabled: boolean) => NodeIntrospection;
+export declare function whyIsNodeRunning({ active, hook }: NodeIntrospection): void;
+export {};

package/dist/why-is-node-running.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableNodeIntrospection = void 0;
+exports.whyIsNodeRunning = whyIsNodeRunning;
+/* eslint-disable no-console */
+const async_hooks_1 = __importDefault(require("async_hooks"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const stackback_1 = require("./stackback");
+const enableNodeIntrospection = (enabled) => {
+    const active = new Map();
+    if (!enabled) {
+        return {
+            active,
+            hook: null,
+        };
+    }
+    const hook = async_hooks_1.default.createHook({
+        init(asyncId, type, _triggerAsyncId, resource) {
+            if (type === 'TIMERWRAP' || type === 'PROMISE')
+                return;
+            if (type === 'PerformanceObserver' || type === 'RANDOMBYTESREQUEST')
+                return;
+            const err = new Error('whatevs');
+            const stacks = (0, stackback_1.stackback)(err);
+            active.set(asyncId, { type, stacks, resource });
+        },
+        destroy(asyncId) {
+            active.delete(asyncId);
+        },
+    });
+    hook.enable();
+    return { hook, active };
+};
+exports.enableNodeIntrospection = enableNodeIntrospection;
+function whyIsNodeRunning({ active, hook }) {
+    if (!hook) {
+        return;
+    }
+    hook.disable();
+    const activeResources = [...active.values()].filter((r) => {
+        if (typeof r.resource.hasRef === 'function' && !r.resource.hasRef())
+            return false;
+        return true;
+    });
+    console.error('There are %d handle(s) keeping the process running', activeResources.length);
+    function printStacks(o) {
+        const stacks = o.stacks.slice(1).filter((s) => {
+            const filename = s.getFileName();
+            return (filename &&
+                filename.indexOf(path_1.sep) > -1 &&
+                filename.indexOf('internal' + path_1.sep) !== 0);
+        });
+        console.error('');
+        console.error('# %s', o.type);
+        if (stacks[0]) {
+            let padding = '';
+            stacks.forEach((s) => {
+                const pad = (s.getFileName() + ':' + s.getLineNumber()).replace(/./g, ' ');
+                if (pad.length > padding.length)
+                    padding = pad;
+            });
+            stacks.forEach((s) => {
+                const prefix = s.getFileName() + ':' + s.getLineNumber();
+                try {
+                    const src = fs_1.default
+                        .readFileSync(s.getFileName(), 'utf-8')
+                        .split(/\n|\r\n/);
+                    console.error(prefix +
+                        padding.slice(prefix.length) +
+                        ' - ' +
+                        src[s.getLineNumber() - 1].trim());
+                }
+                catch (_a) {
+                    console.error(prefix + padding.slice(prefix.length));
+                }
+            });
+        }
+        else {
+            console.error('(unknown stack trace)');
+        }
+    }
+    for (const o of activeResources) {
+        printStacks(o);
+    }
+}

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.244",
+  "version": "4.0.246",
   "description": "A runtime for distributed rendering",
   "main": "dist",
   "sideEffects": false,
@@ -17,13 +17,14 @@
     "access": "public"
   },
   "dependencies": {
-    "remotion": "4.0.244",
-    "@remotion/renderer": "4.0.244",
-    "@remotion/streaming": "4.0.244"
+    "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.244"
+    "@remotion/eslint-config-internal": "4.0.246"
   },
   "exports": {
     ".": "./dist/index.js",