@remotion/cloudrun 4.0.18

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

@@ -0,0 +1,11 @@
+import type { File } from '@google-cloud/storage';
+export type CloudrunLSInput = {
+    bucketName: string;
+    prefix: string;
+};
+export 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,300 @@
+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"]>;
+    serializedInputPropsWithCustomSchema: z.ZodString;
+    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, {
+    type: "media";
+    serveUrl: string;
+    composition: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    serializedInputPropsWithCustomSchema: string;
+    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;
+}, {
+    type: "media";
+    serveUrl: string;
+    composition: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    serializedInputPropsWithCustomSchema: string;
+    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>>;
+    serializedInputPropsWithCustomSchema: z.ZodString;
+    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, {
+    type: "still";
+    serveUrl: string;
+    composition: string;
+    serializedInputPropsWithCustomSchema: string;
+    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;
+}, {
+    type: "still";
+    serveUrl: string;
+    composition: string;
+    serializedInputPropsWithCustomSchema: string;
+    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, {
+    status: "error";
+    error: string;
+    stack: string;
+}, {
+    status: "error";
+    error: string;
+    stack: string;
+}>;
+declare const renderStillOnCloudrunResponsePayload: z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    publicUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cloudStorageUri: z.ZodString;
+    size: z.ZodNumber;
+    bucketName: z.ZodString;
+    renderId: z.ZodString;
+    privacy: z.ZodEnum<["public-read", "project-private"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}>;
+declare const renderMediaOnCloudrunResponsePayload: z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    publicUrl: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    cloudStorageUri: z.ZodString;
+    size: z.ZodNumber;
+    bucketName: z.ZodString;
+    renderId: z.ZodString;
+    privacy: z.ZodEnum<["public-read", "project-private"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}, {
+    status: "success";
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    publicUrl?: string | null | undefined;
+}>;
+declare const cloudRunCrashResponse: z.ZodObject<{
+    status: z.ZodLiteral<"crash">;
+    cloudRunEndpoint: z.ZodString;
+    message: z.ZodLiteral<"Service crashed without sending a response. Check the logs in GCP console.">;
+    requestStartTime: z.ZodString;
+    requestCrashTime: z.ZodString;
+    requestElapsedTimeInSeconds: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    message: "Service crashed without sending a response. Check the logs in GCP console.";
+    status: "crash";
+    cloudRunEndpoint: string;
+    requestStartTime: string;
+    requestCrashTime: string;
+    requestElapsedTimeInSeconds: number;
+}, {
+    message: "Service crashed without sending a response. Check the logs in GCP console.";
+    status: "crash";
+    cloudRunEndpoint: string;
+    requestStartTime: string;
+    requestCrashTime: string;
+    requestElapsedTimeInSeconds: number;
+}>;
+export type CloudRunPayloadType = z.infer<typeof CloudRunPayload>;
+export type RenderStillOnCloudrunOutput = z.infer<typeof renderStillOnCloudrunResponsePayload>;
+export type RenderMediaOnCloudrunOutput = z.infer<typeof renderMediaOnCloudrunResponsePayload>;
+export type ErrorResponsePayload = z.infer<typeof renderFailResponsePayload>;
+export type CloudRunCrashResponse = z.infer<typeof cloudRunCrashResponse>;
+export {};

package/dist/functions/helpers/payloads.js

@@ -0,0 +1,104 @@
+"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,
+        serializedInputPropsWithCustomSchema: zod_1.z.string(),
+        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(),
+        serializedInputPropsWithCustomSchema: zod_1.z.string(),
+        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({
+    status: zod_1.z.literal('success'),
+    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(),
+    privacy: zod_1.z.enum(['public-read', 'project-private']),
+});
+const renderMediaOnCloudrunResponsePayload = zod_1.z.object({
+    status: zod_1.z.literal('success'),
+    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(),
+    privacy: zod_1.z.enum(['public-read', 'project-private']),
+});
+const cloudRunCrashResponse = zod_1.z.object({
+    status: zod_1.z.literal('crash'),
+    cloudRunEndpoint: zod_1.z.string(),
+    message: zod_1.z.literal('Service crashed without sending a response. Check the logs in GCP console.'),
+    requestStartTime: zod_1.z.string().datetime(),
+    requestCrashTime: zod_1.z.string().datetime(),
+    requestElapsedTimeInSeconds: zod_1.z.number(),
+});

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>;

package/dist/functions/render-media-single-thread.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMediaSingleThread = void 0;
+const storage_1 = require("@google-cloud/storage");
+const renderer_1 = require("@remotion/renderer");
+const remotion_1 = require("remotion");
+const random_hash_1 = require("../shared/random-hash");
+const get_composition_from_body_1 = require("./helpers/get-composition-from-body");
+const renderMediaSingleThread = async (body, res) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (body.type !== 'media') {
+        throw new Error('expected type media');
+    }
+    const composition = await (0, get_composition_from_body_1.getCompositionFromBody)(body);
+    const defaultOutName = `out.${renderer_1.RenderInternals.getFileExtensionFromCodec(body.codec, body.audioCodec)}`;
+    const tempFilePath = `/tmp/${defaultOutName}`;
+    const renderId = (0, random_hash_1.randomHash)({ randomInTests: true });
+    let previousProgress = 2;
+    const onProgress = ({ progress }) => {
+        if (previousProgress !== progress) {
+            res.write(JSON.stringify({ onProgress: progress }) + '\n');
+            previousProgress = progress;
+        }
+    };
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    const actualChromiumOptions = {
+        ...body.chromiumOptions,
+        // Override the `null` value, which might come from CLI with swANGLE
+        gl: (_b = (_a = body.chromiumOptions) === null || _a === void 0 ? void 0 : _a.gl) !== null && _b !== void 0 ? _b : 'swangle',
+    };
+    await renderer_1.RenderInternals.internalRenderMedia({
+        composition: {
+            ...composition,
+            height: (_c = body.forceHeight) !== null && _c !== void 0 ? _c : composition.height,
+            width: (_d = body.forceWidth) !== null && _d !== void 0 ? _d : composition.width,
+        },
+        serveUrl: body.serveUrl,
+        codec: body.codec,
+        outputLocation: tempFilePath,
+        serializedInputPropsWithCustomSchema: body.serializedInputPropsWithCustomSchema,
+        serializedResolvedPropsWithCustomSchema: remotion_1.Internals.serializeJSONWithDate({
+            data: composition.props,
+            indent: undefined,
+            staticBase: null,
+        }).serializedString,
+        jpegQuality: body.jpegQuality,
+        audioCodec: body.audioCodec,
+        audioBitrate: body.audioBitrate,
+        videoBitrate: body.videoBitrate,
+        crf: body.crf,
+        pixelFormat: body.pixelFormat,
+        imageFormat: body.imageFormat,
+        scale: body.scale,
+        proResProfile: (_e = body.proResProfile) !== null && _e !== void 0 ? _e : undefined,
+        everyNthFrame: body.everyNthFrame,
+        numberOfGifLoops: body.numberOfGifLoops,
+        onProgress,
+        frameRange: body.frameRange,
+        envVariables: body.envVariables,
+        chromiumOptions: actualChromiumOptions,
+        muted: body.muted,
+        logLevel: body.logLevel,
+        browserExecutable: null,
+        timeoutInMilliseconds: body.delayRenderTimeoutInMilliseconds,
+        cancelSignal: undefined,
+        concurrency: (_f = body.concurrency) !== null && _f !== void 0 ? _f : '100%',
+        disallowParallelEncoding: false,
+        enforceAudioTrack: body.enforceAudioTrack,
+        ffmpegOverride: undefined,
+        indent: false,
+        onBrowserLog: null,
+        onCtrlCExit: () => undefined,
+        onDownload: () => undefined,
+        onStart: () => undefined,
+        overwrite: true,
+        port: null,
+        preferLossless: body.preferLossless,
+        puppeteerInstance: undefined,
+        server: undefined,
+    });
+    const storage = new storage_1.Storage();
+    const publicUpload = body.privacy === 'public' || !body.privacy;
+    const uploadedResponse = await storage
+        .bucket(body.outputBucket)
+        .upload(tempFilePath, {
+        destination: `renders/${renderId}/${(_g = body.outName) !== null && _g !== void 0 ? _g : defaultOutName}`,
+        predefinedAcl: publicUpload ? 'publicRead' : 'projectPrivate',
+    });
+    const uploadedFile = uploadedResponse[0];
+    const renderMetadata = await uploadedFile.getMetadata();
+    const responseData = {
+        status: 'success',
+        publicUrl: publicUpload ? uploadedFile.publicUrl() : null,
+        cloudStorageUri: uploadedFile.cloudStorageURI.href,
+        size: renderMetadata[0].size,
+        bucketName: body.outputBucket,
+        renderId,
+        privacy: publicUpload ? 'public-read' : 'project-private',
+    };
+    renderer_1.RenderInternals.Log.info('Render Completed:', responseData);
+    res.end(JSON.stringify({ response: responseData }));
+};
+exports.renderMediaSingleThread = renderMediaSingleThread;

package/dist/functions/render-still-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 renderStillSingleThread: (body: CloudRunPayloadType, res: ff.Response) => Promise<void>;

package/dist/functions/render-still-single-thread.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderStillSingleThread = void 0;
+const storage_1 = require("@google-cloud/storage");
+const renderer_1 = require("@remotion/renderer");
+const remotion_1 = require("remotion");
+const log_1 = require("../cli/log");
+const random_hash_1 = require("../shared/random-hash");
+const get_composition_from_body_1 = require("./helpers/get-composition-from-body");
+const renderStillSingleThread = async (body, res) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (body.type !== 'still') {
+        throw new Error('expected type still');
+    }
+    log_1.Log.verbose('Rendering still frame', body);
+    const composition = await (0, get_composition_from_body_1.getCompositionFromBody)(body);
+    log_1.Log.verbose('Composition loaded', composition);
+    const tempFilePath = '/tmp/still.png';
+    const renderId = (0, random_hash_1.randomHash)({ randomInTests: true });
+    const actualChromiumOptions = {
+        ...body.chromiumOptions,
+        // Override the `null` value, which might come from CLI with swANGLE
+        gl: (_b = (_a = body.chromiumOptions) === null || _a === void 0 ? void 0 : _a.gl) !== null && _b !== void 0 ? _b : 'swangle',
+    };
+    await renderer_1.RenderInternals.internalRenderStill({
+        composition: {
+            ...composition,
+            height: (_c = body.forceHeight) !== null && _c !== void 0 ? _c : composition.height,
+            width: (_d = body.forceWidth) !== null && _d !== void 0 ? _d : composition.width,
+        },
+        serveUrl: body.serveUrl,
+        output: tempFilePath,
+        serializedInputPropsWithCustomSchema: body.serializedInputPropsWithCustomSchema,
+        serializedResolvedPropsWithCustomSchema: remotion_1.Internals.serializeJSONWithDate({
+            data: composition.props,
+            indent: undefined,
+            staticBase: null,
+        }).serializedString,
+        jpegQuality: (_e = body.jpegQuality) !== null && _e !== void 0 ? _e : renderer_1.RenderInternals.DEFAULT_JPEG_QUALITY,
+        imageFormat: body.imageFormat,
+        scale: body.scale,
+        envVariables: body.envVariables,
+        chromiumOptions: actualChromiumOptions,
+        frame: body.frame,
+        logLevel: body.logLevel,
+        browserExecutable: null,
+        cancelSignal: null,
+        indent: false,
+        timeoutInMilliseconds: body.delayRenderTimeoutInMilliseconds,
+        onBrowserLog: null,
+        onDownload: null,
+        overwrite: true,
+        port: null,
+        puppeteerInstance: null,
+        server: undefined,
+    });
+    log_1.Log.info('Still rendered');
+    const storage = new storage_1.Storage();
+    const publicUpload = body.privacy === 'public' || !body.privacy;
+    const uploadedResponse = await storage
+        .bucket(body.outputBucket)
+        .upload(tempFilePath, {
+        destination: `renders/${renderId}/${(_f = body.outName) !== null && _f !== void 0 ? _f : 'out.png'}`,
+        predefinedAcl: publicUpload ? 'publicRead' : 'projectPrivate',
+    });
+    log_1.Log.info('Still uploaded');
+    const uploadedFile = uploadedResponse[0];
+    const renderMetadata = await uploadedFile.getMetadata();
+    const responseData = {
+        publicUrl: uploadedFile.publicUrl(),
+        cloudStorageUri: uploadedFile.cloudStorageURI.href,
+        size: renderMetadata[0].size,
+        bucketName: body.outputBucket,
+        renderId,
+        status: 'success',
+        privacy: publicUpload ? 'public-read' : 'project-private',
+    };
+    renderer_1.RenderInternals.Log.info('Render Completed:', responseData);
+    const jsonContent = JSON.stringify(responseData);
+    res.end(jsonContent);
+};
+exports.renderStillSingleThread = renderStillSingleThread;