@remotion/cloudrun 4.1.0-alpha2 → 4.1.0-alpha4

package/dist/cli/commands/still.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stillCommand = exports.STILL_COMMAND = void 0;
+const cli_1 = require("@remotion/cli");
+const config_1 = require("@remotion/cli/config");
+const renderer_1 = require("@remotion/renderer");
+const download_file_1 = require("../../api/download-file");
+const render_still_on_cloudrun_1 = require("../../api/render-still-on-cloudrun");
+const validate_serveurl_1 = require("../../shared/validate-serveurl");
+const log_1 = require("../log");
+const renderArgsCheck_1 = require("./render/helpers/renderArgsCheck");
+exports.STILL_COMMAND = 'still';
+const stillCommand = async (args, remotionRoot) => {
+    var _a, _b;
+    const { serveUrl, cloudRunUrl, outName, forceBucketName, privacy, downloadName, region, } = await (0, renderArgsCheck_1.renderArgsCheck)(exports.STILL_COMMAND, args);
+    const { chromiumOptions, envVariables, inputProps, puppeteerTimeout, jpegQuality, stillFrame, scale, height, width, browserExecutable, port, logLevel, } = await cli_1.CliInternals.getCliOptions({
+        type: 'still',
+        isLambda: true,
+        remotionRoot,
+    });
+    let composition = args[1];
+    if (!composition) {
+        log_1.Log.info('No compositions passed. Fetching compositions...');
+        (0, validate_serveurl_1.validateServeUrl)(serveUrl);
+        const server = renderer_1.RenderInternals.prepareServer({
+            concurrency: 1,
+            indent: false,
+            port,
+            remotionRoot,
+            logLevel,
+            webpackConfigOrServeUrl: serveUrl,
+        });
+        const { compositionId } = await cli_1.CliInternals.getCompositionWithDimensionOverride({
+            args,
+            compositionIdFromUi: null,
+            indent: false,
+            serveUrlOrWebpackUrl: serveUrl,
+            logLevel,
+            browserExecutable,
+            chromiumOptions,
+            envVariables,
+            inputProps,
+            port,
+            puppeteerInstance: undefined,
+            timeoutInMilliseconds: puppeteerTimeout,
+            height,
+            width,
+            server: await server,
+        });
+        composition = compositionId;
+    }
+    const { format: imageFormat, source: imageFormatReason } = cli_1.CliInternals.determineFinalStillImageFormat({
+        downloadName,
+        outName: outName !== null && outName !== void 0 ? outName : null,
+        cliFlag: (_a = cli_1.CliInternals.parsedCli['image-format']) !== null && _a !== void 0 ? _a : null,
+        isLambda: true,
+        fromUi: null,
+        configImageFormat: (_b = config_1.ConfigInternals.getUserPreferredStillImageFormat()) !== null && _b !== void 0 ? _b : null,
+    });
+    log_1.Log.verbose(`Image format: (${imageFormat}), ${imageFormatReason}`);
+    // Todo: Check cloudRunUrl is valid, as the error message is obtuse
+    cli_1.CliInternals.Log.info(cli_1.CliInternals.chalk.gray(`
+Cloud Run Service URL = ${cloudRunUrl}
+Region = ${region}
+Type = still
+Composition = ${composition}
+Output Bucket = ${forceBucketName}
+Output File = ${outName !== null && outName !== void 0 ? outName : 'out.png'}
+Output File Privacy = ${privacy}
+${downloadName ? `    Downloaded File = ${downloadName}` : ''}
+			`.trim()));
+    log_1.Log.info();
+    const renderStart = Date.now();
+    const progressBar = cli_1.CliInternals.createOverwriteableCliOutput({
+        quiet: cli_1.CliInternals.quietFlagProvided(),
+        cancelSignal: null,
+        updatesDontOverwrite: false,
+        indent: false,
+    });
+    let doneIn = null;
+    const updateProgress = (newline) => {
+        progressBar.update([
+            `Rendering on Cloud Run:`,
+            `${doneIn === null ? '...' : `Rendered in ${doneIn}ms`}`,
+        ].join(' '), newline);
+    };
+    const res = await (0, render_still_on_cloudrun_1.renderStillOnCloudrun)({
+        cloudRunUrl,
+        serveUrl,
+        region,
+        inputProps,
+        imageFormat,
+        composition,
+        privacy,
+        envVariables,
+        frame: stillFrame,
+        jpegQuality,
+        chromiumOptions,
+        scale,
+        forceHeight: height,
+        forceWidth: width,
+        forceBucketName,
+        outName,
+        logLevel: config_1.ConfigInternals.Logging.getLogLevel(),
+        delayRenderTimeoutInMilliseconds: puppeteerTimeout,
+    });
+    doneIn = Date.now() - renderStart;
+    updateProgress(true);
+    log_1.Log.info(cli_1.CliInternals.chalk.gray(`Cloud Storage Uri = ${res.cloudStorageUri}`));
+    log_1.Log.info(cli_1.CliInternals.chalk.gray(`Render ID = ${res.renderId}`));
+    log_1.Log.info(cli_1.CliInternals.chalk.gray(`${Math.round(Number(res.size) / 1000)} KB, Privacy: ${res.privacy}, Bucket: ${res.bucketName}`));
+    log_1.Log.info(cli_1.CliInternals.chalk.blue(`○ ${res.publicUrl}`));
+    if (downloadName) {
+        log_1.Log.info('');
+        log_1.Log.info('downloading file...');
+        const destination = await (0, download_file_1.downloadFile)({
+            bucketName: res.bucketName,
+            gsutilURI: res.cloudStorageUri,
+            downloadName,
+        });
+        log_1.Log.info(cli_1.CliInternals.chalk.blueBright(`Downloaded file to ${destination}!`));
+    }
+};
+exports.stillCommand = stillCommand;

package/dist/cli/help.js

@@ -8,6 +8,7 @@ const regions_1 = require("./commands/regions");
 const render_1 = require("./commands/render");
 const services_1 = require("./commands/services");
 const sites_1 = require("./commands/sites");
+const still_1 = require("./commands/still");
 const log_1 = require("./log");
 const packagejson = require('../../package.json');
 const printHelp = () => {
@@ -17,7 +18,10 @@ const printHelp = () => {
     log_1.Log.info('');
     log_1.Log.info();
     log_1.Log.info(`${constants_1.BINARY_NAME} ${render_1.RENDER_COMMAND}`);
-    log_1.Log.info(cli_1.CliInternals.chalk.gray('Render Remotion media/still on GCP Cloud Run.'));
+    log_1.Log.info(cli_1.CliInternals.chalk.gray('Render Remotion media on GCP Cloud Run.'));
+    log_1.Log.info();
+    log_1.Log.info(`${constants_1.BINARY_NAME} ${still_1.STILL_COMMAND}`);
+    log_1.Log.info(cli_1.CliInternals.chalk.gray('Render Remotion still on GCP Cloud Run.'));
     log_1.Log.info();
     log_1.Log.info(`${constants_1.BINARY_NAME} ${services_1.SERVICES_COMMAND}`);
     log_1.Log.info(cli_1.CliInternals.chalk.gray('Deploy and manage Cloud Run services on GCP.'));

package/dist/cli/index.js

@@ -5,6 +5,7 @@ const args_1 = require("./args");
 const permissions_1 = require("./commands/permissions");
 const regions_1 = require("./commands/regions");
 const render_1 = require("./commands/render");
+const still_1 = require("./commands/still");
 const services_1 = require("./commands/services");
 const sites_1 = require("./commands/sites");
 const help_1 = require("./help");
@@ -18,6 +19,9 @@ const matchCommand = (args, remotionRoot) => {
     if (args[0] === render_1.RENDER_COMMAND) {
         return (0, render_1.renderCommand)(args.slice(1), remotionRoot);
     }
+    if (args[0] === still_1.STILL_COMMAND) {
+        return (0, still_1.stillCommand)(args.slice(1), remotionRoot);
+    }
     if (args[0] === services_1.SERVICES_COMMAND) {
         return (0, services_1.servicesCommand)(args.slice(1));
     }

package/dist/cli/log.d.ts

@@ -5,7 +5,6 @@ export declare const Log: {
         logLevel: "error" | "verbose" | "info" | "warn";
     } & {
         tag?: string | undefined;
-        secondTag?: string | undefined;
     }, message?: any, ...optionalParams: any[]) => void;
     info: (message?: any, ...optionalParams: any[]) => void;
     infoAdvanced: (options: {

package/dist/functions/helpers/get-composition-from-body.d.ts

@@ -0,0 +1 @@
+export declare const getCompositionFromBody: (serveUrl: string, compositionName: string) => Promise<import("remotion").AnyCompMetadata>;

package/dist/functions/helpers/get-composition-from-body.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompositionFromBody = void 0;
+const renderer_1 = require("@remotion/renderer");
+const getCompositionFromBody = async (serveUrl, compositionName) => {
+    const comps = await (0, renderer_1.getCompositions)(serveUrl);
+    const composition = comps.find((comp) => comp.id === compositionName);
+    if (composition) {
+        return composition;
+    }
+    throw new Error(`Composition not found: ${compositionName}`);
+};
+exports.getCompositionFromBody = getCompositionFromBody;

package/dist/functions/helpers/io.d.ts

@@ -0,0 +1,11 @@
+import type { File } from '@google-cloud/storage';
+export declare type CloudrunLSInput = {
+    bucketName: string;
+    prefix: string;
+};
+export declare type CloudrunLsReturnType = Promise<File[]>;
+export declare const cloudrunLs: ({ bucketName, prefix, }: CloudrunLSInput) => CloudrunLsReturnType;
+export declare const cloudrunDeleteFile: ({ bucketName, key, }: {
+    bucketName: string;
+    key: string;
+}) => Promise<void>;

package/dist/functions/helpers/io.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloudrunDeleteFile = exports.cloudrunLs = void 0;
+const get_cloud_storage_client_1 = require("../../api/helpers/get-cloud-storage-client");
+const cloudrunLs = async ({ bucketName, prefix, }) => {
+    const cloudStorageClient = (0, get_cloud_storage_client_1.getCloudStorageClient)();
+    const [files] = await cloudStorageClient
+        .bucket(bucketName)
+        .getFiles({ prefix, autoPaginate: true });
+    return files;
+};
+exports.cloudrunLs = cloudrunLs;
+const cloudrunDeleteFile = async ({ bucketName, key, }) => {
+    const cloudStorageClient = (0, get_cloud_storage_client_1.getCloudStorageClient)();
+    await cloudStorageClient.bucket(bucketName).file(key).delete();
+};
+exports.cloudrunDeleteFile = cloudrunDeleteFile;

package/dist/functions/helpers/payloads.d.ts

@@ -0,0 +1,277 @@
+import { z } from 'zod';
+export declare const CloudRunPayload: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"media">;
+    serveUrl: z.ZodString;
+    composition: z.ZodString;
+    forceHeight: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    forceWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    codec: z.ZodEnum<["h264", "h265", "vp8", "vp9", "mp3", "aac", "wav", "prores", "h264-mkv", "gif"]>;
+    inputProps: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    jpegQuality: z.ZodNumber;
+    audioCodec: z.ZodNullable<z.ZodEnum<["pcm-16", "aac", "mp3", "opus"]>>;
+    audioBitrate: z.ZodNullable<z.ZodString>;
+    videoBitrate: z.ZodNullable<z.ZodString>;
+    crf: z.ZodNullable<z.ZodNumber>;
+    pixelFormat: z.ZodEnum<["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"]>;
+    imageFormat: z.ZodEnum<["png", "jpeg", "none"]>;
+    scale: z.ZodNumber;
+    proResProfile: z.ZodNullable<z.ZodEnum<["4444-xq", "4444", "hq", "standard", "light", "proxy"]>>;
+    everyNthFrame: z.ZodNumber;
+    numberOfGifLoops: z.ZodNullable<z.ZodNumber>;
+    frameRange: z.ZodNullable<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodNumber]>>;
+    envVariables: z.ZodRecord<z.ZodString, z.ZodString>;
+    chromiumOptions: z.ZodOptional<z.ZodObject<{
+        ignoreCertificateErrors: z.ZodOptional<z.ZodBoolean>;
+        disableWebSecurity: z.ZodOptional<z.ZodBoolean>;
+        gl: z.ZodNullable<z.ZodOptional<z.ZodEnum<["swangle", "angle", "egl", "swiftshader"]>>>;
+        headless: z.ZodOptional<z.ZodBoolean>;
+        userAgent: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }>>;
+    muted: z.ZodBoolean;
+    outputBucket: z.ZodString;
+    outName: z.ZodOptional<z.ZodString>;
+    privacy: z.ZodOptional<z.ZodEnum<["public", "private"]>>;
+    logLevel: z.ZodEnum<["verbose", "info", "warn", "error"]>;
+    delayRenderTimeoutInMilliseconds: z.ZodNumber;
+    concurrency: z.ZodNullable<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    enforceAudioTrack: z.ZodBoolean;
+    preferLossless: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    serveUrl: string;
+    type: "media";
+    composition: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    inputProps: Record<string, unknown>;
+    jpegQuality: number;
+    audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    crf: number | null;
+    pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    imageFormat: "png" | "jpeg" | "none";
+    scale: number;
+    proResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    frameRange: ((number | [number, number]) & (number | [number, number] | undefined)) | null;
+    envVariables: Record<string, string>;
+    muted: boolean;
+    outputBucket: string;
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    concurrency: string | number | null;
+    enforceAudioTrack: boolean;
+    preferLossless: boolean;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+    privacy?: "public" | "private" | undefined;
+}, {
+    serveUrl: string;
+    type: "media";
+    composition: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    inputProps: Record<string, unknown>;
+    jpegQuality: number;
+    audioCodec: "mp3" | "aac" | "pcm-16" | "opus" | null;
+    audioBitrate: string | null;
+    videoBitrate: string | null;
+    crf: number | null;
+    pixelFormat: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le";
+    imageFormat: "png" | "jpeg" | "none";
+    scale: number;
+    proResProfile: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | null;
+    everyNthFrame: number;
+    numberOfGifLoops: number | null;
+    frameRange: ((number | [number, number]) & (number | [number, number] | undefined)) | null;
+    envVariables: Record<string, string>;
+    muted: boolean;
+    outputBucket: string;
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    concurrency: string | number | null;
+    enforceAudioTrack: boolean;
+    preferLossless: boolean;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+    privacy?: "public" | "private" | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"still">;
+    serveUrl: z.ZodString;
+    composition: z.ZodString;
+    forceHeight: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    forceWidth: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    inputProps: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    jpegQuality: z.ZodOptional<z.ZodNumber>;
+    imageFormat: z.ZodEnum<["png", "jpeg", "pdf", "webp"]>;
+    scale: z.ZodNumber;
+    privacy: z.ZodEnum<["public", "private"]>;
+    envVariables: z.ZodRecord<z.ZodString, z.ZodString>;
+    chromiumOptions: z.ZodOptional<z.ZodObject<{
+        ignoreCertificateErrors: z.ZodOptional<z.ZodBoolean>;
+        disableWebSecurity: z.ZodOptional<z.ZodBoolean>;
+        gl: z.ZodNullable<z.ZodOptional<z.ZodEnum<["swangle", "angle", "egl", "swiftshader"]>>>;
+        headless: z.ZodOptional<z.ZodBoolean>;
+        userAgent: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }, {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    }>>;
+    outputBucket: z.ZodString;
+    outName: z.ZodOptional<z.ZodString>;
+    frame: z.ZodNumber;
+    delayRenderTimeoutInMilliseconds: z.ZodNumber;
+    logLevel: z.ZodEnum<["verbose", "info", "warn", "error"]>;
+}, "strip", z.ZodTypeAny, {
+    serveUrl: string;
+    type: "still";
+    composition: string;
+    inputProps: Record<string, unknown>;
+    imageFormat: "png" | "jpeg" | "pdf" | "webp";
+    scale: number;
+    envVariables: Record<string, string>;
+    outputBucket: string;
+    privacy: "public" | "private";
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    frame: number;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    jpegQuality?: number | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+}, {
+    serveUrl: string;
+    type: "still";
+    composition: string;
+    inputProps: Record<string, unknown>;
+    imageFormat: "png" | "jpeg" | "pdf" | "webp";
+    scale: number;
+    envVariables: Record<string, string>;
+    outputBucket: string;
+    privacy: "public" | "private";
+    logLevel: "error" | "verbose" | "info" | "warn";
+    delayRenderTimeoutInMilliseconds: number;
+    frame: number;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    jpegQuality?: number | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    outName?: string | undefined;
+}>]>;
+declare const renderFailResponsePayload: z.ZodObject<{
+    status: z.ZodLiteral<"error">;
+    error: z.ZodString;
+    stack: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    error: string;
+    status: "error";
+    stack: string;
+}, {
+    error: string;
+    status: "error";
+    stack: string;
+}>;
+declare const renderStillOnCloudrunResponsePayload: z.ZodObject<{
+    publicUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cloudStorageUri: z.ZodString;
+    size: z.ZodNumber;
+    bucketName: z.ZodString;
+    renderId: z.ZodString;
+    status: z.ZodLiteral<"success">;
+    privacy: z.ZodEnum<["public-read", "project-private"]>;
+}, "strip", z.ZodTypeAny, {
+    bucketName: string;
+    size: number;
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}, {
+    bucketName: string;
+    size: number;
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}>;
+declare const renderMediaOnCloudrunResponsePayload: z.ZodObject<{
+    publicUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cloudStorageUri: z.ZodString;
+    size: z.ZodNumber;
+    bucketName: z.ZodString;
+    renderId: z.ZodString;
+    status: z.ZodLiteral<"success">;
+    privacy: z.ZodEnum<["public-read", "project-private"]>;
+}, "strip", z.ZodTypeAny, {
+    bucketName: string;
+    size: number;
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}, {
+    bucketName: string;
+    size: number;
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}>;
+export declare type CloudRunPayloadType = z.infer<typeof CloudRunPayload>;
+export declare type RenderStillOnCloudrunOutput = z.infer<typeof renderStillOnCloudrunResponsePayload>;
+export declare type RenderMediaOnCloudrunOutput = z.infer<typeof renderMediaOnCloudrunResponsePayload>;
+export declare type ErrorResponsePayload = z.infer<typeof renderFailResponsePayload>;
+export {};

package/dist/functions/helpers/payloads.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloudRunPayload = void 0;
+const renderer_1 = require("@remotion/renderer");
+const client_1 = require("@remotion/renderer/client");
+const zod_1 = require("zod");
+const codec = zod_1.z.enum(renderer_1.RenderInternals.validCodecs);
+const audioCodec = zod_1.z.enum(renderer_1.RenderInternals.validAudioCodecs);
+const pixelFormat = zod_1.z.enum(renderer_1.RenderInternals.validPixelFormats);
+const videoImageFormat = zod_1.z.enum(renderer_1.RenderInternals.validVideoImageFormats);
+const stillImageFormat = zod_1.z.enum(renderer_1.RenderInternals.validStillImageFormats);
+const proResProfile = zod_1.z.enum(client_1.BrowserSafeApis.proResProfileOptions).nullable();
+const chromiumOptions = zod_1.z.object({
+    ignoreCertificateErrors: zod_1.z.boolean().optional(),
+    disableWebSecurity: zod_1.z.boolean().optional(),
+    gl: zod_1.z.enum(renderer_1.RenderInternals.validOpenGlRenderers).optional().nullable(),
+    headless: zod_1.z.boolean().optional(),
+    userAgent: zod_1.z.string().optional().nullable(),
+});
+const logLevel = zod_1.z.enum(renderer_1.RenderInternals.logLevels);
+exports.CloudRunPayload = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({
+        type: zod_1.z.literal('media'),
+        serveUrl: zod_1.z.string(),
+        composition: zod_1.z.string(),
+        forceHeight: zod_1.z.number().optional().nullable(),
+        forceWidth: zod_1.z.number().optional().nullable(),
+        codec,
+        inputProps: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+        jpegQuality: zod_1.z.number(),
+        audioCodec: audioCodec.nullable(),
+        audioBitrate: zod_1.z.string().nullable(),
+        videoBitrate: zod_1.z.string().nullable(),
+        crf: zod_1.z.number().nullable(),
+        pixelFormat,
+        imageFormat: videoImageFormat,
+        scale: zod_1.z.number(),
+        proResProfile,
+        everyNthFrame: zod_1.z.number(),
+        numberOfGifLoops: zod_1.z.number().nullable(),
+        frameRange: zod_1.z.tuple([zod_1.z.number(), zod_1.z.number()]).or(zod_1.z.number()).nullable(),
+        envVariables: zod_1.z.record(zod_1.z.string()),
+        chromiumOptions: chromiumOptions.optional(),
+        muted: zod_1.z.boolean(),
+        outputBucket: zod_1.z.string(),
+        outName: zod_1.z.string().optional(),
+        privacy: zod_1.z.enum(['public', 'private']).optional(),
+        logLevel,
+        delayRenderTimeoutInMilliseconds: zod_1.z.number(),
+        concurrency: zod_1.z.number().or(zod_1.z.string()).nullable(),
+        enforceAudioTrack: zod_1.z.boolean(),
+        preferLossless: zod_1.z.boolean(),
+    }),
+    zod_1.z.object({
+        type: zod_1.z.literal('still'),
+        serveUrl: zod_1.z.string(),
+        composition: zod_1.z.string(),
+        forceHeight: zod_1.z.number().optional().nullable(),
+        forceWidth: zod_1.z.number().optional().nullable(),
+        inputProps: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+        jpegQuality: zod_1.z.number().optional(),
+        imageFormat: stillImageFormat,
+        scale: zod_1.z.number(),
+        privacy: zod_1.z.enum(['public', 'private']),
+        envVariables: zod_1.z.record(zod_1.z.string()),
+        chromiumOptions: chromiumOptions.optional(),
+        outputBucket: zod_1.z.string(),
+        outName: zod_1.z.string().optional(),
+        frame: zod_1.z.number(),
+        delayRenderTimeoutInMilliseconds: zod_1.z.number(),
+        logLevel,
+    }),
+]);
+const renderFailResponsePayload = zod_1.z.object({
+    status: zod_1.z.literal('error'),
+    error: zod_1.z.string(),
+    stack: zod_1.z.string(),
+});
+const renderStillOnCloudrunResponsePayload = zod_1.z.object({
+    publicUrl: zod_1.z.string().optional().nullable(),
+    cloudStorageUri: zod_1.z.string(),
+    size: zod_1.z.number(),
+    bucketName: zod_1.z.string(),
+    renderId: zod_1.z.string(),
+    status: zod_1.z.literal('success'),
+    privacy: zod_1.z.enum(['public-read', 'project-private']),
+});
+const renderMediaOnCloudrunResponsePayload = zod_1.z.object({
+    publicUrl: zod_1.z.string().optional().nullable(),
+    cloudStorageUri: zod_1.z.string(),
+    size: zod_1.z.number(),
+    bucketName: zod_1.z.string(),
+    renderId: zod_1.z.string(),
+    status: zod_1.z.literal('success'),
+    privacy: zod_1.z.enum(['public-read', 'project-private']),
+});

package/dist/functions/index.d.ts

@@ -0,0 +1,3 @@
+import type * as ff from '@google-cloud/functions-framework';
+declare const renderOnCloudRun: (req: ff.Request, res: ff.Response) => Promise<void>;
+export { renderOnCloudRun };

package/dist/functions/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderOnCloudRun = void 0;
+const renderer_1 = require("@remotion/renderer");
+const log_1 = require("../cli/log");
+const payloads_1 = require("./helpers/payloads");
+const render_media_single_thread_1 = require("./render-media-single-thread");
+const render_still_single_thread_1 = require("./render-still-single-thread");
+const renderOnCloudRun = async (req, res) => {
+    var _a;
+    try {
+        log_1.Log.info('renderOnCloudRun', req.body);
+        const body = payloads_1.CloudRunPayload.parse(req.body);
+        const renderType = body.type;
+        renderer_1.RenderInternals.setLogLevel(body.logLevel);
+        switch (renderType) {
+            case 'media':
+                await (0, render_media_single_thread_1.renderMediaSingleThread)(body, res);
+                break;
+            case 'still':
+                await (0, render_still_single_thread_1.renderStillSingleThread)(body, res);
+                break;
+            default:
+                res
+                    .status(400)
+                    .send('Invalid render type, must be either "media" or "still"');
+        }
+    }
+    catch (err) {
+        log_1.Log.error('Error while rendering', err);
+        const response = {
+            error: err.message,
+            status: 'error',
+            stack: (_a = err.stack) !== null && _a !== void 0 ? _a : '',
+        };
+        res.status(500).send(JSON.stringify(response));
+    }
+};
+exports.renderOnCloudRun = renderOnCloudRun;

package/dist/functions/render-media-single-thread.d.ts

@@ -0,0 +1,3 @@
+import type * as ff from '@google-cloud/functions-framework';
+import type { CloudRunPayloadType } from './helpers/payloads';
+export declare const renderMediaSingleThread: (body: CloudRunPayloadType, res: ff.Response) => Promise<void>;