@remotion/lambda 4.0.256 → 4.0.258

package/dist/functions/helpers/on-downloads-logger.d.ts

@@ -1,2 +0,0 @@
-import type { LogLevel, RenderMediaOnDownload } from '@remotion/renderer';
-export declare const onDownloadsHelper: (logLevel: LogLevel) => RenderMediaOnDownload;

package/dist/functions/helpers/on-downloads-logger.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.onDownloadsHelper = void 0;
-const renderer_1 = require("@remotion/renderer");
-const onDownloadsHelper = (logLevel) => {
-    const downloads = {};
-    return (src) => {
-        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Downloading', src);
-        downloads[src] = 0;
-        return ({ percent, downloaded }) => {
-            if (percent === null) {
-                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Download progress (${src}): ${downloaded} bytes. Don't know final size of download, no Content-Length header.`);
-                return;
-            }
-            if (
-            // Only report every 10% change
-            downloads[src] > percent - 0.1 &&
-                percent !== 1) {
-                return;
-            }
-            downloads[src] = percent;
-            renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Download progress (${src}): ${downloaded} bytes, ${(percent * 100).toFixed(1)}%`);
-            if (percent === 1) {
-                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Download complete: ${src}`);
-            }
-        };
-    };
-};
-exports.onDownloadsHelper = onDownloadsHelper;

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

@@ -1,59 +0,0 @@
-import type { LogLevel } from '@remotion/renderer';
-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';
-export type OverallRenderProgress<Provider extends CloudProvider> = {
-    chunks: number[];
-    framesRendered: number;
-    framesEncoded: number;
-    combinedFrames: number;
-    timeToCombine: number | null;
-    timeToEncode: number | null;
-    timeToRenderFrames: number | null;
-    lambdasInvoked: number;
-    retries: ChunkRetry[];
-    postRenderData: PostRenderData<Provider> | null;
-    timings: ParsedTiming[];
-    renderMetadata: RenderMetadata<Provider> | null;
-    errors: LambdaErrorInfo[];
-    timeoutTimestamp: number;
-    functionLaunched: number;
-    serveUrlOpened: number | null;
-    compositionValidated: number | null;
-    receivedArtifact: ReceivedArtifact<Provider>[];
-};
-export type OverallProgressHelper<Provider extends CloudProvider> = {
-    upload: () => Promise<void>;
-    setFrames: ({ encoded, rendered, index, }: {
-        rendered: number;
-        encoded: number;
-        index: number;
-    }) => void;
-    setLambdaInvoked: (chunk: number) => void;
-    addChunkCompleted: (chunkIndex: number, start: number, rendered: number) => void;
-    setCombinedFrames: (framesEncoded: number) => void;
-    setTimeToCombine: (timeToCombine: number) => void;
-    addRetry: (retry: ChunkRetry) => void;
-    setPostRenderData: (postRenderData: PostRenderData<Provider>) => void;
-    setRenderMetadata: (renderMetadata: RenderMetadata<Provider>) => void;
-    addErrorWithoutUpload: (errorInfo: LambdaErrorInfo) => void;
-    setExpectedChunks: (expectedChunks: number) => void;
-    get: () => OverallRenderProgress<Provider>;
-    setServeUrlOpened: (timestamp: number) => void;
-    setCompositionValidated: (timestamp: number) => void;
-    addReceivedArtifact: (asset: ReceivedArtifact<Provider>) => void;
-    getReceivedArtifacts: () => ReceivedArtifact<Provider>[];
-};
-export declare const makeInitialOverallRenderProgress: <Provider extends CloudProvider>(timeoutTimestamp: number) => OverallRenderProgress<Provider>;
-export declare const makeOverallRenderProgress: <Provider extends CloudProvider>({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, }: {
-    renderId: string;
-    bucketName: string;
-    expectedBucketOwner: string;
-    region: Provider["region"];
-    timeoutTimestamp: number;
-    logLevel: LogLevel;
-    providerSpecifics: ProviderSpecifics<Provider>;
-    forcePathStyle: boolean;
-}) => OverallProgressHelper<Provider>;

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

@@ -1,180 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeOverallRenderProgress = exports.makeInitialOverallRenderProgress = void 0;
-const renderer_1 = require("@remotion/renderer");
-const client_1 = require("@remotion/serverless/client");
-const makeInitialOverallRenderProgress = (timeoutTimestamp) => {
-    return {
-        chunks: [],
-        framesRendered: 0,
-        framesEncoded: 0,
-        combinedFrames: 0,
-        timeToCombine: null,
-        timeToEncode: null,
-        lambdasInvoked: 0,
-        retries: [],
-        postRenderData: null,
-        timings: [],
-        renderMetadata: null,
-        errors: [],
-        timeToRenderFrames: null,
-        timeoutTimestamp,
-        functionLaunched: Date.now(),
-        serveUrlOpened: null,
-        compositionValidated: null,
-        receivedArtifact: [],
-    };
-};
-exports.makeInitialOverallRenderProgress = makeInitialOverallRenderProgress;
-const makeOverallRenderProgress = ({ renderId, bucketName, expectedBucketOwner, region, timeoutTimestamp, logLevel, providerSpecifics, forcePathStyle, }) => {
-    let framesRendered = [];
-    let framesEncoded = [];
-    let lambdasInvoked = [];
-    const renderProgress = (0, exports.makeInitialOverallRenderProgress)(timeoutTimestamp);
-    let currentUploadPromise = null;
-    const getCurrentProgress = () => renderProgress;
-    let latestUploadRequest = 0;
-    const getLatestRequestId = () => latestUploadRequest;
-    let encodeStartTime = null;
-    let renderFramesStartTime = null;
-    const upload = async () => {
-        const uploadRequestId = ++latestUploadRequest;
-        if (currentUploadPromise) {
-            await currentUploadPromise;
-        }
-        // If request has been replaced by a new one
-        if (getLatestRequestId() !== uploadRequestId) {
-            return;
-        }
-        const toWrite = JSON.stringify(getCurrentProgress());
-        const start = Date.now();
-        currentUploadPromise = providerSpecifics
-            .writeFile({
-            body: toWrite,
-            bucketName,
-            customCredentials: null,
-            downloadBehavior: null,
-            expectedBucketOwner,
-            key: (0, client_1.overallProgressKey)(renderId),
-            privacy: 'private',
-            region,
-            forcePathStyle,
-        })
-            .then(() => {
-            // By default, upload is way too fast (~20 requests per second)
-            // Space out the requests a bit
-            return new Promise((resolve) => {
-                setTimeout(resolve, 250 - (Date.now() - start));
-            });
-        })
-            .catch((err) => {
-            // If an error occurs in uploading the state that contains the errors,
-            // that is unfortunate. We just log it.
-            renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, 'Error uploading progress', err);
-        });
-        await currentUploadPromise;
-        currentUploadPromise = null;
-    };
-    return {
-        upload,
-        setFrames: ({ encoded, rendered, index, }) => {
-            if (framesRendered.length === 0) {
-                throw new Error('Expected chunks to be set before frames are set');
-            }
-            if (framesEncoded.length === 0) {
-                throw new Error('Expected chunks to be set before frames are set');
-            }
-            framesRendered[index] = rendered;
-            framesEncoded[index] = encoded;
-            const totalFramesEncoded = framesEncoded.reduce((a, b) => a + b, 0);
-            const totalFramesRendered = framesRendered.reduce((a, b) => a + b, 0);
-            if (renderProgress.framesEncoded === 0 && totalFramesEncoded > 0) {
-                encodeStartTime = Date.now();
-            }
-            if (renderProgress.framesRendered === 0 && totalFramesRendered > 0) {
-                renderFramesStartTime = Date.now();
-            }
-            if (renderProgress.timeToRenderFrames === null) {
-                const frameCount = renderProgress.renderMetadata &&
-                    renderProgress.renderMetadata.type === 'video'
-                    ? renderer_1.RenderInternals.getFramesToRender(renderProgress.renderMetadata.frameRange, renderProgress.renderMetadata.everyNthFrame).length
-                    : null;
-                if (frameCount === totalFramesRendered) {
-                    const timeToRenderFrames = Date.now() - (renderFramesStartTime !== null && renderFramesStartTime !== void 0 ? renderFramesStartTime : Date.now());
-                    renderProgress.timeToRenderFrames = timeToRenderFrames;
-                }
-            }
-            renderProgress.framesRendered = totalFramesRendered;
-            renderProgress.framesEncoded = totalFramesEncoded;
-            upload();
-        },
-        addChunkCompleted: (chunkIndex, start, rendered) => {
-            var _a;
-            renderProgress.chunks.push(chunkIndex);
-            if (renderProgress.chunks.length ===
-                ((_a = renderProgress.renderMetadata) === null || _a === void 0 ? void 0 : _a.totalChunks)) {
-                const timeToEncode = Date.now() - (encodeStartTime !== null && encodeStartTime !== void 0 ? encodeStartTime : Date.now());
-                renderProgress.timeToEncode = timeToEncode;
-            }
-            renderProgress.timings.push({
-                chunk: chunkIndex,
-                start,
-                rendered,
-            });
-            upload();
-        },
-        setCombinedFrames: (frames) => {
-            renderProgress.combinedFrames = frames;
-            upload();
-        },
-        setTimeToCombine: (timeToCombine) => {
-            renderProgress.timeToCombine = timeToCombine;
-            upload();
-        },
-        setLambdaInvoked(chunk) {
-            if (lambdasInvoked.length === 0) {
-                throw new Error('Expected chunks to be set before lambdas are set');
-            }
-            lambdasInvoked[chunk] = true;
-            renderProgress.lambdasInvoked = lambdasInvoked.reduce((a, b) => a + Number(b), 0);
-            upload();
-        },
-        setPostRenderData(postRenderData) {
-            renderProgress.postRenderData = postRenderData;
-            upload();
-        },
-        setRenderMetadata: (renderMetadata) => {
-            renderProgress.renderMetadata = renderMetadata;
-            upload();
-        },
-        addErrorWithoutUpload: (errorInfo) => {
-            renderProgress.errors.push(errorInfo);
-        },
-        setExpectedChunks: (expectedChunks) => {
-            framesRendered = new Array(expectedChunks).fill(0);
-            framesEncoded = new Array(expectedChunks).fill(0);
-            lambdasInvoked = new Array(expectedChunks).fill(false);
-        },
-        setCompositionValidated(timestamp) {
-            renderProgress.compositionValidated = timestamp;
-            upload();
-        },
-        setServeUrlOpened(timestamp) {
-            renderProgress.serveUrlOpened = timestamp;
-            upload();
-        },
-        addRetry(retry) {
-            renderProgress.retries.push(retry);
-            upload();
-        },
-        addReceivedArtifact(asset) {
-            renderProgress.receivedArtifact.push(asset);
-            upload();
-        },
-        getReceivedArtifacts() {
-            return renderProgress.receivedArtifact;
-        },
-        get: () => renderProgress,
-    };
-};
-exports.makeOverallRenderProgress = makeOverallRenderProgress;

package/dist/functions/helpers/print-concurrency-curve.d.ts

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

package/dist/functions/helpers/print-concurrency-curve.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const best_frames_per_lambda_param_1 = require("./best-frames-per-lambda-param");
-const entries = [];
-for (let i = 0; i < 18000; i += 100) {
-    entries.push([i, (0, best_frames_per_lambda_param_1.bestFramesPerLambdaParam)(i)]);
-}
-console.log(entries.map((e) => e.join(',')).join('\n'));

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

@@ -1,4 +0,0 @@
-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

@@ -1,12 +0,0 @@
-"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/render-has-audio-video.d.ts

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

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

@@ -1,21 +0,0 @@
-"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/functions/helpers/request-context.d.ts

@@ -1,5 +0,0 @@
-export type RequestContext = {
-    invokedFunctionArn: string;
-    getRemainingTimeInMillis: () => number;
-    awsRequestId: string;
-};

package/dist/functions/helpers/request-context.js

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

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

@@ -1,17 +0,0 @@
-import type { EmittedArtifact, LogLevel } from '@remotion/renderer';
-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: <Provider extends CloudProvider>({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, }: {
-    payload: ServerlessPayload<Provider>;
-    functionName: string;
-    outdir: string;
-    overallProgress: OverallProgressHelper<Provider>;
-    files: string[];
-    logLevel: LogLevel;
-    onArtifact: (asset: EmittedArtifact) => {
-        alreadyExisted: boolean;
-    };
-    providerSpecifics: ProviderSpecifics<Provider>;
-}) => Promise<unknown>;

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

@@ -1,148 +0,0 @@
-"use strict";
-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 call_lambda_1 = require("../../shared/call-lambda");
-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) => {
-        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, 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) {
-                    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}`);
-        };
-        (0, call_lambda_1.callLambdaWithStreaming)({
-            functionName,
-            payload,
-            retriesRemaining: 1,
-            region: providerSpecifics.getCurrentRegionInFunction(),
-            timeoutInTest: 12000,
-            type: client_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 !== client_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/functions/launch.d.ts

@@ -1,10 +0,0 @@
-import type { CloudProvider, ProviderSpecifics } from '@remotion/serverless';
-import type { ServerlessPayload } from '@remotion/serverless/client';
-type Options = {
-    expectedBucketOwner: string;
-    getRemainingTimeInMillis: () => number;
-};
-export declare const launchHandler: <Provider extends CloudProvider>(params: ServerlessPayload<Provider>, options: Options, providerSpecifics: ProviderSpecifics<Provider>) => Promise<{
-    type: "success";
-}>;
-export {};