@remotion/cloudrun 4.1.0-alpha2 → 4.1.0-alpha3

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

@@ -0,0 +1,262 @@
+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.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodUndefined]>;
+    jpegQuality: z.ZodOptional<z.ZodNumber>;
+    audioCodec: z.ZodNullable<z.ZodOptional<z.ZodEnum<["pcm-16", "aac", "mp3", "opus"]>>>;
+    audioBitrate: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    videoBitrate: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    crf: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    pixelFormat: z.ZodOptional<z.ZodEnum<["yuv420p", "yuva420p", "yuv422p", "yuv444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuva444p10le"]>>;
+    imageFormat: z.ZodOptional<z.ZodEnum<["png", "jpeg", "none"]>>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    proResProfile: z.ZodOptional<z.ZodEnum<["4444-xq", "4444", "hq", "standard", "light", "proxy"]>>;
+    everyNthFrame: z.ZodOptional<z.ZodNumber>;
+    numberOfGifLoops: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    frameRange: z.ZodOptional<z.ZodUnion<[z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>, z.ZodNumber]>>;
+    envVariables: z.ZodOptional<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.ZodOptional<z.ZodBoolean>;
+    outputBucket: z.ZodString;
+    outName: z.ZodOptional<z.ZodString>;
+    privacy: z.ZodOptional<z.ZodEnum<["public", "private"]>>;
+    logLevel: z.ZodEnum<["verbose", "info", "warn", "error"]>;
+}, "strip", z.ZodTypeAny, {
+    serveUrl: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    logLevel: "verbose" | "info" | "warn" | "error";
+    composition: string;
+    type: "media";
+    outputBucket: string;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    inputProps?: Record<string, unknown> | undefined;
+    jpegQuality?: number | undefined;
+    audioCodec?: "mp3" | "aac" | "pcm-16" | "opus" | null | undefined;
+    audioBitrate?: string | null | undefined;
+    videoBitrate?: string | null | undefined;
+    crf?: number | null | undefined;
+    pixelFormat?: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le" | undefined;
+    imageFormat?: "png" | "jpeg" | "none" | undefined;
+    scale?: number | undefined;
+    proResProfile?: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | undefined;
+    everyNthFrame?: number | undefined;
+    numberOfGifLoops?: number | null | undefined;
+    frameRange?: number | [number, number] | undefined;
+    envVariables?: Record<string, string> | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    muted?: boolean | undefined;
+    outName?: string | undefined;
+    privacy?: "public" | "private" | undefined;
+}, {
+    serveUrl: string;
+    codec: "h264" | "h265" | "vp8" | "vp9" | "mp3" | "aac" | "wav" | "prores" | "h264-mkv" | "gif";
+    logLevel: "verbose" | "info" | "warn" | "error";
+    composition: string;
+    type: "media";
+    outputBucket: string;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    inputProps?: Record<string, unknown> | undefined;
+    jpegQuality?: number | undefined;
+    audioCodec?: "mp3" | "aac" | "pcm-16" | "opus" | null | undefined;
+    audioBitrate?: string | null | undefined;
+    videoBitrate?: string | null | undefined;
+    crf?: number | null | undefined;
+    pixelFormat?: "yuv420p" | "yuva420p" | "yuv422p" | "yuv444p" | "yuv420p10le" | "yuv422p10le" | "yuv444p10le" | "yuva444p10le" | undefined;
+    imageFormat?: "png" | "jpeg" | "none" | undefined;
+    scale?: number | undefined;
+    proResProfile?: "4444-xq" | "4444" | "hq" | "standard" | "light" | "proxy" | undefined;
+    everyNthFrame?: number | undefined;
+    numberOfGifLoops?: number | null | undefined;
+    frameRange?: number | [number, number] | undefined;
+    envVariables?: Record<string, string> | undefined;
+    chromiumOptions?: {
+        ignoreCertificateErrors?: boolean | undefined;
+        disableWebSecurity?: boolean | undefined;
+        gl?: "swangle" | "angle" | "egl" | "swiftshader" | null | undefined;
+        headless?: boolean | undefined;
+        userAgent?: string | null | undefined;
+    } | undefined;
+    muted?: boolean | 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.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodUndefined]>;
+    jpegQuality: z.ZodOptional<z.ZodNumber>;
+    imageFormat: z.ZodOptional<z.ZodEnum<["png", "jpeg", "pdf", "webp"]>>;
+    scale: z.ZodOptional<z.ZodNumber>;
+    privacy: z.ZodOptional<z.ZodEnum<["public", "private"]>>;
+    envVariables: z.ZodOptional<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;
+    logLevel: z.ZodEnum<["verbose", "info", "warn", "error"]>;
+}, "strip", z.ZodTypeAny, {
+    serveUrl: string;
+    logLevel: "verbose" | "info" | "warn" | "error";
+    composition: string;
+    type: "still";
+    frame: number;
+    outputBucket: string;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    inputProps?: Record<string, unknown> | undefined;
+    jpegQuality?: number | undefined;
+    imageFormat?: "png" | "jpeg" | "pdf" | "webp" | undefined;
+    scale?: number | undefined;
+    privacy?: "public" | "private" | undefined;
+    envVariables?: Record<string, string> | 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;
+    logLevel: "verbose" | "info" | "warn" | "error";
+    composition: string;
+    type: "still";
+    frame: number;
+    outputBucket: string;
+    forceHeight?: number | null | undefined;
+    forceWidth?: number | null | undefined;
+    inputProps?: Record<string, unknown> | undefined;
+    jpegQuality?: number | undefined;
+    imageFormat?: "png" | "jpeg" | "pdf" | "webp" | undefined;
+    scale?: number | undefined;
+    privacy?: "public" | "private" | undefined;
+    envVariables?: Record<string, string> | 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, {
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    status: "success";
+    publicUrl?: string | null | undefined;
+}, {
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    status: "success";
+    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, {
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    status: "success";
+    publicUrl?: string | null | undefined;
+}, {
+    privacy: "public-read" | "project-private";
+    cloudStorageUri: string;
+    size: number;
+    bucketName: string;
+    renderId: string;
+    status: "success";
+    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,91 @@
+"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);
+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()).or(zod_1.z.undefined()),
+        jpegQuality: zod_1.z.number().optional(),
+        audioCodec: audioCodec.optional().nullable(),
+        audioBitrate: zod_1.z.string().optional().nullable(),
+        videoBitrate: zod_1.z.string().optional().nullable(),
+        crf: zod_1.z.number().optional().nullable(),
+        pixelFormat: pixelFormat.optional(),
+        imageFormat: videoImageFormat.optional(),
+        scale: zod_1.z.number().optional(),
+        proResProfile: proResProfile.optional(),
+        everyNthFrame: zod_1.z.number().optional(),
+        numberOfGifLoops: zod_1.z.number().optional().nullable(),
+        frameRange: zod_1.z.tuple([zod_1.z.number(), zod_1.z.number()]).or(zod_1.z.number()).optional(),
+        envVariables: zod_1.z.record(zod_1.z.string()).optional(),
+        chromiumOptions: chromiumOptions.optional(),
+        muted: zod_1.z.boolean().optional(),
+        outputBucket: zod_1.z.string(),
+        outName: zod_1.z.string().optional(),
+        privacy: zod_1.z.enum(['public', 'private']).optional(),
+        logLevel,
+    }),
+    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()).or(zod_1.z.undefined()),
+        jpegQuality: zod_1.z.number().optional(),
+        imageFormat: stillImageFormat.optional(),
+        scale: zod_1.z.number().optional(),
+        privacy: zod_1.z.enum(['public', 'private']).optional(),
+        envVariables: zod_1.z.record(zod_1.z.string()).optional(),
+        chromiumOptions: chromiumOptions.optional(),
+        outputBucket: zod_1.z.string(),
+        outName: zod_1.z.string().optional(),
+        frame: 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,38 @@
+"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;
+    const body = payloads_1.CloudRunPayload.parse(req.body);
+    const renderType = body.type;
+    renderer_1.RenderInternals.setLogLevel(body.logLevel);
+    try {
+        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,79 @@
+"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 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;
+    if (body.type !== 'media') {
+        throw new Error('expected type media');
+    }
+    const composition = await (0, get_composition_from_body_1.getCompositionFromBody)(body.serveUrl, body.composition);
+    const tempFilePath = '/tmp/output.mp4';
+    const renderId = (0, random_hash_1.randomHash)({ randomInTests: true });
+    let previousProgress = 2;
+    const onProgress = ({ progress }) => {
+        if (previousProgress !== progress) {
+            res.write(JSON.stringify({ onProgress: progress }));
+            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 (0, renderer_1.renderMedia)({
+        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,
+        inputProps: body.inputProps,
+        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: body.proResProfile,
+        everyNthFrame: body.everyNthFrame,
+        numberOfGifLoops: body.numberOfGifLoops,
+        onProgress,
+        frameRange: body.frameRange,
+        envVariables: body.envVariables,
+        chromiumOptions: actualChromiumOptions,
+        muted: body.muted,
+        verbose: renderer_1.RenderInternals.isEqualOrBelowLogLevel(body.logLevel, 'verbose'),
+    });
+    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}/${(_e = body.outName) !== null && _e !== void 0 ? _e : 'out.mp4'}`,
+        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,66 @@
+"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 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;
+    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.serveUrl, body.composition);
+    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 (0, renderer_1.renderStill)({
+        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,
+        inputProps: body.inputProps,
+        jpegQuality: body.jpegQuality,
+        imageFormat: body.imageFormat,
+        scale: body.scale,
+        envVariables: body.envVariables,
+        chromiumOptions: actualChromiumOptions,
+        frame: body.frame,
+        verbose: renderer_1.RenderInternals.isEqualOrBelowLogLevel(body.logLevel, 'verbose'),
+    });
+    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}/${(_e = body.outName) !== null && _e !== void 0 ? _e : '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;

package/dist/shared/generate-service-name.js

@@ -14,7 +14,7 @@ const generateServiceName = ({ memoryLimit, cpuLimit, timeoutSeconds, }) => {
         (0, service_version_string_1.serviceVersionString)(),
         `mem${sanitisedMem}`,
         `cpu${sanitisedCPU}`,
-        `t-${String(timeoutSeconds)}`,
-    ].join('--');
+        `t${String(timeoutSeconds)}`,
+    ].join('-');
 };
 exports.generateServiceName = generateServiceName;

package/dist/shared/service-version-string.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.serviceVersionString = void 0;
 const version_1 = require("remotion/version");
 const serviceVersionString = () => {
-    return version_1.VERSION.replace(/\./g, '-').replace(/\+/g, '-').substring(0, 10);
+    return version_1.VERSION.replace(/\./g, '-').replace(/\+/g, '-');
 };
 exports.serviceVersionString = serviceVersionString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/cloudrun",
-  "version": "4.1.0-alpha2",
+  "version": "4.1.0-alpha3",
   "description": "GCP Cloud Run alternative to lambda rendering",
   "main": "dist/index.js",
   "dependencies": {
@@ -11,10 +11,10 @@
     "@google-cloud/resource-manager": "^4.3.0",
     "google-auth-library": "^8.7.0",
     "zod": "^3.21.4",
-    "@remotion/bundler": "4.1.0-alpha2",
-    "@remotion/cli": "4.1.0-alpha2",
-    "@remotion/renderer": "4.1.0-alpha2",
-    "remotion": "4.1.0-alpha2"
+    "@remotion/bundler": "4.1.0-alpha3",
+    "@remotion/renderer": "4.1.0-alpha3",
+    "@remotion/cli": "4.1.0-alpha3",
+    "remotion": "4.1.0-alpha3"
   },
   "devDependencies": {
     "@jonny/eslint-config": "3.0.266",
@@ -26,7 +26,7 @@
     "ts-node": "^10.8.0",
     "typescript": "4.7.2",
     "vitest": "0.24.3",
-    "@remotion/compositor-linux-x64-gnu": "4.1.0-alpha2"
+    "@remotion/compositor-linux-x64-gnu": "4.1.0-alpha3"
   },
   "exports": {
     "./package.json": "./package.json",
@@ -45,15 +45,13 @@
       ]
     }
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "scripts": {
     "build": "tsc -d && cp src/shared/sa-permissions.json dist/shared/sa-permissions.json && pnpm run buildContainer && pnpm run tarInstaller",
     "buildContainer": "ts-node src/admin/bundle-renderLogic.ts",
     "tarInstaller": "ts-node src/admin/bundle-installer.ts",
     "start": "functions-framework --target=TypescriptFunction",
     "watch": "tsc -w",
-    "lint": "eslint src --ext ts,tsx"
+    "lint": "eslint src --ext ts,tsx",
+    "test": "vitest --run"
   }
 }