@remotion/serverless 4.0.516 → 4.0.518

package/dist/artifact-registry.d.ts

@@ -0,0 +1,23 @@
+import type { EmittedArtifact } from '@remotion/renderer';
+type ArtifactRegistration = {
+    chunk: number;
+    frame: number;
+    attempt: number;
+    filename: string;
+};
+export type ArtifactRegistrationResult = {
+    type: 'accepted';
+} | {
+    type: 'retry-replay';
+} | {
+    type: 'conflict';
+};
+export type OnArtifactFromRenderer = (params: {
+    artifact: EmittedArtifact;
+    chunk: number;
+    attempt: number;
+}) => ArtifactRegistrationResult;
+export declare const makeArtifactRegistry: () => {
+    registerArtifact: (artifact: ArtifactRegistration) => ArtifactRegistrationResult;
+};
+export {};

package/dist/artifact-registry.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeArtifactRegistry = void 0;
+const makeArtifactRegistry = () => {
+    const artifactsByFilename = new Map();
+    const artifactsByAttempt = new Set();
+    const registerArtifact = (artifact) => {
+        const attemptKey = JSON.stringify([
+            artifact.chunk,
+            artifact.attempt,
+            artifact.filename,
+        ]);
+        if (artifactsByAttempt.has(attemptKey)) {
+            return { type: 'conflict' };
+        }
+        artifactsByAttempt.add(attemptKey);
+        const existingArtifact = artifactsByFilename.get(artifact.filename);
+        if (!existingArtifact) {
+            artifactsByFilename.set(artifact.filename, artifact);
+            return { type: 'accepted' };
+        }
+        if (existingArtifact.chunk === artifact.chunk &&
+            existingArtifact.frame === artifact.frame &&
+            artifact.attempt > existingArtifact.attempt) {
+            return { type: 'retry-replay' };
+        }
+        return { type: 'conflict' };
+    };
+    return { registerArtifact };
+};
+exports.makeArtifactRegistry = makeArtifactRegistry;

package/dist/finish-render.d.ts

@@ -0,0 +1,24 @@
+import type { CloudProvider, CustomCredentials, DownloadBehavior, PostRenderData, Privacy, ProviderSpecifics, RenderMetadata, SerializedInputProps } from '@remotion/serverless-client';
+import type { OverallProgressHelper } from './overall-render-progress';
+import type { InsideFunctionSpecifics } from './provider-implementation';
+export declare const finishRender: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ expectedBucketOwner, renderBucketName, customCredentials, downloadBehavior, key, privacy, inputProps, serializedResolvedProps, renderMetadata, logLevel, overallProgress, startTime, providerSpecifics, insideFunctionSpecifics, forcePathStyle, storageClass, requestHandler, outputFile, timeToCombine, }: {
+    expectedBucketOwner: string;
+    renderBucketName: string;
+    customCredentials: CustomCredentials<Provider> | null;
+    downloadBehavior: DownloadBehavior;
+    key: string;
+    privacy: Privacy;
+    inputProps: SerializedInputProps;
+    serializedResolvedProps: SerializedInputProps;
+    renderMetadata: RenderMetadata<Provider>;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    overallProgress: OverallProgressHelper<Provider>;
+    startTime: number;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
+    forcePathStyle: boolean;
+    storageClass: Provider["storageClass"] | null;
+    requestHandler: Provider["requestHandler"] | null;
+    outputFile: string;
+    timeToCombine: number | null;
+}) => Promise<PostRenderData<Provider>>;

package/dist/finish-render.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finishRender = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const serverless_client_1 = require("@remotion/serverless-client");
+const cleanup_props_1 = require("./cleanup-props");
+const create_post_render_data_1 = require("./create-post-render-data");
+const finishRender = async ({ expectedBucketOwner, renderBucketName, customCredentials, downloadBehavior, key, privacy, inputProps, serializedResolvedProps, renderMetadata, logLevel, overallProgress, startTime, providerSpecifics, insideFunctionSpecifics, forcePathStyle, storageClass, requestHandler, outputFile, timeToCombine, }) => {
+    const outputSize = node_fs_1.default.statSync(outputFile).size;
+    const writeToBucket = insideFunctionSpecifics.timer(`Writing to bucket (${outputSize} bytes)`, logLevel);
+    await providerSpecifics.writeFile({
+        bucketName: renderBucketName,
+        key,
+        body: node_fs_1.default.createReadStream(outputFile),
+        region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+        privacy,
+        expectedBucketOwner,
+        downloadBehavior,
+        customCredentials,
+        forcePathStyle,
+        storageClass,
+        requestHandler,
+    });
+    writeToBucket.end();
+    const errorExplanations = (0, serverless_client_1.inspectErrors)({
+        errors: overallProgress.get().errors,
+    });
+    const cleanupProm = (0, cleanup_props_1.cleanupProps)({
+        inputProps,
+        serializedResolvedProps,
+        providerSpecifics,
+        forcePathStyle,
+        insideFunctionSpecifics,
+    });
+    const { url: outputUrl } = providerSpecifics.getOutputUrl({
+        bucketName: renderBucketName,
+        currentRegion: insideFunctionSpecifics.getCurrentRegionInFunction(),
+        customCredentials,
+        renderMetadata,
+    });
+    const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
+        region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+        memorySizeInMb: insideFunctionSpecifics.getCurrentMemorySizeInMb(),
+        renderMetadata,
+        errorExplanations,
+        timeToDelete: (await cleanupProm).reduce((a, b) => Math.max(a, b), 0),
+        outputFile: {
+            sizeInBytes: outputSize,
+            url: outputUrl,
+        },
+        outputSize,
+        timeToCombine,
+        overallProgress: overallProgress.get(),
+        timeToFinish: Date.now() - startTime,
+        providerSpecifics,
+    });
+    await overallProgress.setPostRenderData(postRenderData);
+    node_fs_1.default.unlinkSync(outputFile);
+    return postRenderData;
+};
+exports.finishRender = finishRender;

package/dist/handlers/launch.d.ts

@@ -1,8 +1,10 @@
 import type { CloudProvider, ProviderSpecifics, ServerlessPayload } from '@remotion/serverless-client';
 import type { InsideFunctionSpecifics } from '../provider-implementation';
+import type { RequestContext } from './renderer';
 type Options = {
     expectedBucketOwner: string;
     getRemainingTimeInMillis: () => number;
+    requestContext: RequestContext | null;
 };
 export declare const launchHandler: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ params, options, providerSpecifics, insideFunctionSpecifics, }: {
     params: ServerlessPayload<Provider>;

package/dist/handlers/launch.js

@@ -6,13 +6,16 @@ const path_1 = require("path");
 const renderer_1 = require("@remotion/renderer");
 const serverless_client_1 = require("@remotion/serverless-client");
 const serverless_client_2 = require("@remotion/serverless-client");
+const artifact_registry_1 = require("../artifact-registry");
 const cleanup_props_1 = require("../cleanup-props");
 const find_output_file_in_bucket_1 = require("../find-output-file-in-bucket");
+const finish_render_1 = require("../finish-render");
 const get_tmp_dir_1 = require("../get-tmp-dir");
 const merge_chunks_1 = require("../merge-chunks");
 const overall_render_progress_1 = require("../overall-render-progress");
 const plan_frame_ranges_1 = require("../plan-frame-ranges");
 const remove_outname_credentials_1 = require("../remove-outname-credentials");
+const render_with_single_function_1 = require("../render-with-single-function");
 const stream_renderer_1 = require("../stream-renderer");
 const validate_composition_1 = require("../validate-composition");
 const send_telemetry_event_1 = require("./send-telemetry-event");
@@ -223,16 +226,18 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
     });
     renderer_1.RenderInternals.Log.info(logOptions, 'Render plan: ', chunks.map((c, i) => `Chunk ${i} (Frames ${c[0]} - ${c[1]})`).join(', '));
     const rendererFunctionName = (_j = params.rendererFunctionName) !== null && _j !== void 0 ? _j : insideFunctionSpecifics.getCurrentFunctionName();
+    const shouldRenderDirectly = params.concurrency === 1 &&
+        params.rendererFunctionName === null &&
+        options.requestContext !== null;
     const renderMetadata = {
         startedDate,
         totalChunks: chunks.length,
         estimatedTotalLambdaInvokations: [
-            // Direct invokations
-            chunks.length,
+            shouldRenderDirectly ? 0 : chunks.length,
             // This function
             1,
         ].reduce((a, b) => a + b, 0),
-        estimatedRenderLambdaInvokations: chunks.length,
+        estimatedRenderLambdaInvokations: shouldRenderDirectly ? 0 : chunks.length,
         compositionId: comp.id,
         siteId: params.serveUrl,
         codec: params.codec,
@@ -290,20 +295,17 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
         findOutputFile.end();
     }
     overallProgress.setRenderMetadata(renderMetadata);
-    const outdir = (0, path_1.join)(renderer_1.RenderInternals.tmpDir(serverless_client_2.CONCAT_FOLDER_TOKEN), 'bucket');
-    if ((0, fs_1.existsSync)(outdir)) {
-        (0, fs_1.rmSync)(outdir, {
-            recursive: true,
-        });
-    }
-    (0, fs_1.mkdirSync)(outdir);
-    const files = [];
-    const onArtifact = (artifact) => {
+    const artifactRegistry = (0, artifact_registry_1.makeArtifactRegistry)();
+    const onArtifact = ({ artifact, chunk, attempt }) => {
         var _a;
-        if (overallProgress
-            .getReceivedArtifacts()
-            .find((a) => a.filename === artifact.filename)) {
-            return { alreadyExisted: true };
+        const artifactRegistration = artifactRegistry.registerArtifact({
+            chunk,
+            frame: artifact.frame,
+            attempt,
+            filename: artifact.filename,
+        });
+        if (artifactRegistration.type !== 'accepted') {
+            return artifactRegistration;
         }
         const region = insideFunctionSpecifics.getCurrentRegionInFunction();
         const storageKey = (0, serverless_client_2.artifactName)(renderMetadata.renderId, artifact.filename);
@@ -340,70 +342,122 @@ const innerLaunchHandler = async ({ params, options, overallProgress, registerCl
                 stack: err.stack,
                 tmpDir: null,
                 frame: artifact.frame,
-                chunk: null,
+                chunk,
                 isFatal: false,
-                attempt: 1,
+                attempt,
                 willRetry: false,
                 totalAttempts: 1,
             });
             overallProgress.upload('artifactWriteError');
             renderer_1.RenderInternals.Log.error({ indent: false, logLevel: params.logLevel }, 'Failed to write artifact to S3', err);
         });
-        return { alreadyExisted: false };
+        return artifactRegistration;
     };
-    await Promise.all(lambdaPayloads.map(async (payload) => {
-        await (0, stream_renderer_1.renderRendererFunctionWithRetry)({
-            files,
-            functionName: rendererFunctionName,
-            outdir,
+    let postRenderData;
+    if (shouldRenderDirectly) {
+        const directRender = await (0, render_with_single_function_1.renderWithSingleFunction)({
+            params,
+            composition: comp,
+            serializedInputPropsWithCustomSchema,
+            frameRange: realFrameRange,
+            browserInstance: instance,
+            chromiumOptions: chromiumParams,
             overallProgress,
-            payload,
-            logLevel: params.logLevel,
             onArtifact,
             providerSpecifics,
             insideFunctionSpecifics,
-            requestHandler: null,
+        });
+        try {
+            postRenderData = await (0, finish_render_1.finishRender)({
+                expectedBucketOwner: options.expectedBucketOwner,
+                renderBucketName,
+                customCredentials,
+                downloadBehavior: params.downloadBehavior,
+                key,
+                privacy: params.privacy,
+                inputProps: params.inputProps,
+                serializedResolvedProps,
+                renderMetadata,
+                logLevel: params.logLevel,
+                overallProgress,
+                startTime,
+                providerSpecifics,
+                insideFunctionSpecifics,
+                forcePathStyle: params.forcePathStyle,
+                storageClass: params.storageClass,
+                requestHandler: null,
+                outputFile: directRender.outputFile,
+                timeToCombine: null,
+            });
+        }
+        finally {
+            await directRender.cleanup();
+        }
+    }
+    else {
+        const outdir = (0, path_1.join)(renderer_1.RenderInternals.tmpDir(serverless_client_2.CONCAT_FOLDER_TOKEN), 'bucket');
+        if ((0, fs_1.existsSync)(outdir)) {
+            (0, fs_1.rmSync)(outdir, {
+                recursive: true,
+            });
+        }
+        (0, fs_1.mkdirSync)(outdir);
+        const files = [];
+        await Promise.all(lambdaPayloads.map(async (payload) => {
+            await (0, stream_renderer_1.renderRendererFunctionWithRetry)({
+                files,
+                functionName: rendererFunctionName,
+                outdir,
+                overallProgress,
+                payload,
+                logLevel: params.logLevel,
+                onArtifact,
+                providerSpecifics,
+                insideFunctionSpecifics,
+                requestHandler: null,
+                expectedBucketOwner: options.expectedBucketOwner,
+            });
+        }));
+        postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
+            bucketName: params.bucketName,
+            renderId: params.renderId,
             expectedBucketOwner: options.expectedBucketOwner,
+            numberOfFrames: comp.durationInFrames,
+            audioCodec: params.audioCodec,
+            chunkCount: chunks.length,
+            codec: params.codec,
+            customCredentials,
+            downloadBehavior: params.downloadBehavior,
+            fps,
+            key,
+            numberOfGifLoops: params.numberOfGifLoops,
+            privacy: params.privacy,
+            renderBucketName,
+            inputProps: params.inputProps,
+            serializedResolvedProps,
+            renderMetadata,
+            audioBitrate: params.audioBitrate,
+            logLevel: params.logLevel,
+            framesPerLambda,
+            binariesDirectory: null,
+            preferLossless: params.preferLossless,
+            compositionStart: realFrameRange[0],
+            outdir,
+            files: files.sort(),
+            overallProgress,
+            startTime,
+            providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+            insideFunctionSpecifics,
+            everyNthFrame: params.everyNthFrame,
+            frameRange: params.frameRange,
+            storageClass: params.storageClass,
+            requestHandler: null,
+            sampleRate: params.sampleRate,
         });
-    }));
-    const postRenderData = await (0, merge_chunks_1.mergeChunksAndFinishRender)({
-        bucketName: params.bucketName,
-        renderId: params.renderId,
-        expectedBucketOwner: options.expectedBucketOwner,
-        numberOfFrames: comp.durationInFrames,
-        audioCodec: params.audioCodec,
-        chunkCount: chunks.length,
-        codec: params.codec,
-        customCredentials,
-        downloadBehavior: params.downloadBehavior,
-        fps,
-        key,
-        numberOfGifLoops: params.numberOfGifLoops,
-        privacy: params.privacy,
-        renderBucketName,
-        inputProps: params.inputProps,
-        serializedResolvedProps,
-        renderMetadata,
-        audioBitrate: params.audioBitrate,
-        logLevel: params.logLevel,
-        framesPerLambda,
-        binariesDirectory: null,
-        preferLossless: params.preferLossless,
-        compositionStart: realFrameRange[0],
-        outdir,
-        files: files.sort(),
-        overallProgress,
-        startTime,
-        providerSpecifics,
-        forcePathStyle: params.forcePathStyle,
-        insideFunctionSpecifics,
-        everyNthFrame: params.everyNthFrame,
-        frameRange: params.frameRange,
-        storageClass: params.storageClass,
-        requestHandler: null,
-        sampleRate: params.sampleRate,
-    });
-    if (providerSpecifics.getRendererFunctionTransport(insideFunctionSpecifics.getCurrentRegionInFunction()) === 's3') {
+    }
+    if (!shouldRenderDirectly &&
+        providerSpecifics.getRendererFunctionTransport(insideFunctionSpecifics.getCurrentRegionInFunction()) === 's3') {
         try {
             const transportObjects = await providerSpecifics.listObjects({
                 bucketName: params.bucketName,

package/dist/handlers/renderer.d.ts

@@ -9,7 +9,7 @@ export type RequestContext = {
     getRemainingTimeInMillis: () => number;
     awsRequestId: string;
 };
-export declare const rendererHandler: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, onMediaFiles, }: {
+export declare const rendererHandler: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, onMediaFiles, executionMode, }: {
     params: ServerlessPayload<Provider>;
     options: Options;
     onStream: OnStream<Provider>;
@@ -22,5 +22,6 @@ export declare const rendererHandler: <Provider extends CloudProvider<string, Re
         isAudioOnly: boolean;
         completedAt: number;
     }) => Promise<void>) | null;
+    executionMode: "direct" | "invoked";
 }) => Promise<void>;
 export {};

package/dist/handlers/renderer.js

@@ -285,9 +285,9 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
     streamTimer.end();
     renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: params.logLevel }, 'Cleaning up and writing timings');
     await Promise.all([
-        node_fs_1.default.promises.rm(videoOutputLocation, { recursive: true }),
+        node_fs_1.default.promises.rm(videoOutputLocation, { recursive: true, force: true }),
         audioOutputLocation
-            ? node_fs_1.default.promises.rm(audioOutputLocation, { recursive: true })
+            ? node_fs_1.default.promises.rm(audioOutputLocation, { recursive: true, force: true })
             : null,
         node_fs_1.default.promises.rm(outputPath, { recursive: true }),
     ].filter(serverless_client_1.truthy));
@@ -295,7 +295,7 @@ const renderHandler = async ({ params, options, logs, onStream, providerSpecific
     return {};
 };
 const ENABLE_SLOW_LEAK_DETECTION = false;
-const rendererHandler = async ({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, onMediaFiles, }) => {
+const rendererHandler = async ({ onStream, options, params, providerSpecifics, requestContext, insideFunctionSpecifics, onMediaFiles, executionMode, }) => {
     if (params.type !== serverless_client_1.ServerlessRoutines.renderer) {
         throw new Error('Params must be renderer');
     }
@@ -374,7 +374,12 @@ const rendererHandler = async ({ onStream, options, params, providerSpecifics, r
     }
     finally {
         stopCancellationPolling();
-        if (shouldKeepBrowserOpen && instance) {
+        if (executionMode === 'direct') {
+            if (!shouldKeepBrowserOpen && instance) {
+                await instance.instance.close({ silent: true });
+            }
+        }
+        else if (shouldKeepBrowserOpen && instance) {
             insideFunctionSpecifics.forgetBrowserEventLoop({
                 logLevel: params.logLevel,
                 launchedBrowser: instance,

package/dist/inner-routine.js

@@ -159,6 +159,7 @@ const innerHandler = async ({ params, responseWriter, context, providerSpecifics
             options: {
                 expectedBucketOwner: currentUserId,
                 getRemainingTimeInMillis: context.getRemainingTimeInMillis,
+                requestContext: context,
             },
             providerSpecifics,
             insideFunctionSpecifics,
@@ -236,6 +237,7 @@ const innerHandler = async ({ params, responseWriter, context, providerSpecifics
                         });
                     },
                 onMediaFiles: (_a = s3Output === null || s3Output === void 0 ? void 0 : s3Output.uploadMediaAndComplete) !== null && _a !== void 0 ? _a : null,
+                executionMode: 'invoked',
                 requestContext: context,
                 providerSpecifics,
                 insideFunctionSpecifics,

package/dist/merge-chunks.js

@@ -1,14 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeChunksAndFinishRender = void 0;
-const fs_1 = __importDefault(require("fs"));
-const serverless_client_1 = require("@remotion/serverless-client");
-const cleanup_props_1 = require("./cleanup-props");
 const concat_videos_1 = require("./concat-videos");
-const create_post_render_data_1 = require("./create-post-render-data");
+const finish_render_1 = require("./finish-render");
 const mergeChunksAndFinishRender = async (options) => {
     const onProgress = ({ frames: framesEncoded }) => {
         options.overallProgress.setCombinedFrames(framesEncoded);
@@ -43,56 +37,27 @@ const mergeChunksAndFinishRender = async (options) => {
     });
     const encodingStop = Date.now();
     options.overallProgress.setTimeToCombine(encodingStop - encodingStart);
-    const outputSize = fs_1.default.statSync(outfile).size;
-    const writeToBucket = options.insideFunctionSpecifics.timer(`Writing to bucket (${outputSize} bytes)`, options.logLevel);
-    await options.providerSpecifics.writeFile({
-        bucketName: options.renderBucketName,
-        key: options.key,
-        body: fs_1.default.createReadStream(outfile),
-        region: options.insideFunctionSpecifics.getCurrentRegionInFunction(),
-        privacy: options.privacy,
+    const postRenderData = await (0, finish_render_1.finishRender)({
         expectedBucketOwner: options.expectedBucketOwner,
-        downloadBehavior: options.downloadBehavior,
+        renderBucketName: options.renderBucketName,
         customCredentials: options.customCredentials,
-        forcePathStyle: options.forcePathStyle,
-        storageClass: options.storageClass,
-        requestHandler: options.requestHandler,
-    });
-    writeToBucket.end();
-    const errorExplanations = (0, serverless_client_1.inspectErrors)({
-        errors: options.overallProgress.get().errors,
-    });
-    const cleanupProm = (0, cleanup_props_1.cleanupProps)({
+        downloadBehavior: options.downloadBehavior,
+        key: options.key,
+        privacy: options.privacy,
         inputProps: options.inputProps,
         serializedResolvedProps: options.serializedResolvedProps,
+        renderMetadata: options.renderMetadata,
+        logLevel: options.logLevel,
+        overallProgress: options.overallProgress,
+        startTime: options.startTime,
         providerSpecifics: options.providerSpecifics,
-        forcePathStyle: options.forcePathStyle,
         insideFunctionSpecifics: options.insideFunctionSpecifics,
-    });
-    const { url: outputUrl } = options.providerSpecifics.getOutputUrl({
-        bucketName: options.renderBucketName,
-        currentRegion: options.insideFunctionSpecifics.getCurrentRegionInFunction(),
-        customCredentials: options.customCredentials,
-        renderMetadata: options.renderMetadata,
-    });
-    const postRenderData = (0, create_post_render_data_1.createPostRenderData)({
-        region: options.insideFunctionSpecifics.getCurrentRegionInFunction(),
-        memorySizeInMb: options.insideFunctionSpecifics.getCurrentMemorySizeInMb(),
-        renderMetadata: options.renderMetadata,
-        errorExplanations,
-        timeToDelete: (await cleanupProm).reduce((a, b) => Math.max(a, b), 0),
-        outputFile: {
-            sizeInBytes: outputSize,
-            url: outputUrl,
-        },
-        outputSize,
+        forcePathStyle: options.forcePathStyle,
+        storageClass: options.storageClass,
+        requestHandler: options.requestHandler,
+        outputFile: outfile,
         timeToCombine: encodingStop - encodingStart,
-        overallProgress: options.overallProgress.get(),
-        timeToFinish: Date.now() - options.startTime,
-        providerSpecifics: options.providerSpecifics,
     });
-    await options.overallProgress.setPostRenderData(postRenderData);
-    fs_1.default.unlinkSync(outfile);
     await cleanupChunksProm;
     return postRenderData;
 };

package/dist/render-with-single-function.d.ts

@@ -0,0 +1,20 @@
+import type { ChromiumOptions, ResolvedFrameRange } from '@remotion/renderer';
+import type { CloudProvider, ProviderSpecifics, ServerlessPayload, VideoConfig } from '@remotion/serverless-client';
+import type { OnArtifactFromRenderer } from './artifact-registry';
+import type { OverallProgressHelper } from './overall-render-progress';
+import type { InsideFunctionSpecifics } from './provider-implementation';
+export declare const renderWithSingleFunction: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ params, composition, serializedInputPropsWithCustomSchema, frameRange, browserInstance, chromiumOptions, overallProgress, onArtifact, providerSpecifics, insideFunctionSpecifics, }: {
+    params: ServerlessPayload<Provider>;
+    composition: VideoConfig;
+    serializedInputPropsWithCustomSchema: string;
+    frameRange: ResolvedFrameRange;
+    browserInstance: import("@remotion/renderer").HeadlessBrowser;
+    chromiumOptions: ChromiumOptions;
+    overallProgress: OverallProgressHelper<Provider>;
+    onArtifact: OnArtifactFromRenderer;
+    providerSpecifics: ProviderSpecifics<Provider>;
+    insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
+}) => Promise<{
+    outputFile: string;
+    cleanup: () => Promise<void>;
+}>;

package/dist/render-with-single-function.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderWithSingleFunction = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = require("node:path");
+const renderer_1 = require("@remotion/renderer");
+const serverless_client_1 = require("@remotion/serverless-client");
+const cancellation_polling_1 = require("./cancellation-polling");
+const on_downloads_helpers_1 = require("./on-downloads-helpers");
+const renderWithSingleFunction = async ({ params, composition, serializedInputPropsWithCustomSchema, frameRange, browserInstance, chromiumOptions, overallProgress, onArtifact, providerSpecifics, insideFunctionSpecifics, }) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (params.type !== serverless_client_1.ServerlessRoutines.launch) {
+        throw new Error('Expected launch type');
+    }
+    const outputDirectory = renderer_1.RenderInternals.tmpDir('remotion-direct-render-');
+    const outputFile = (0, node_path_1.join)(outputDirectory, `output.${renderer_1.RenderInternals.getFileExtensionFromCodec(params.codec, params.audioCodec)}`);
+    const cleanup = () => node_fs_1.default.promises.rm(outputDirectory, { recursive: true, force: true });
+    const frameCount = renderer_1.RenderInternals.getFramesToRender(frameRange, params.everyNthFrame).length;
+    const startedAt = Date.now();
+    const { cancel, cancelSignal } = (0, renderer_1.makeCancelSignal)();
+    const stopCancellationPolling = params.enableCancellation
+        ? (0, cancellation_polling_1.startCancellationPolling)({
+            bucketName: params.bucketName,
+            renderId: params.renderId,
+            region: insideFunctionSpecifics.getCurrentRegionInFunction(),
+            providerSpecifics,
+            forcePathStyle: params.forcePathStyle,
+            intervalInMilliseconds: 1000,
+            logLevel: params.logLevel,
+            onCancelled: cancel,
+        })
+        : () => undefined;
+    try {
+        await (0, renderer_1.renderMedia)({
+            composition,
+            serveUrl: params.serveUrl,
+            codec: params.codec,
+            outputLocation: outputFile,
+            inputProps: JSON.parse(serializedInputPropsWithCustomSchema),
+            imageFormat: params.imageFormat,
+            frameRange,
+            concurrency: params.concurrencyPerFunction,
+            puppeteerInstance: browserInstance,
+            jpegQuality: (_a = params.jpegQuality) !== null && _a !== void 0 ? _a : renderer_1.RenderInternals.DEFAULT_JPEG_QUALITY,
+            envVariables: (_b = params.envVariables) !== null && _b !== void 0 ? _b : {},
+            logLevel: params.logLevel,
+            crf: params.crf,
+            pixelFormat: (_c = params.pixelFormat) !== null && _c !== void 0 ? _c : undefined,
+            proResProfile: (_d = params.proResProfile) !== null && _d !== void 0 ? _d : undefined,
+            x264Preset: params.x264Preset,
+            gopSize: (_e = params.gopSize) !== null && _e !== void 0 ? _e : null,
+            onDownload: (0, on_downloads_helpers_1.onDownloadsHelper)(params.logLevel),
+            overwrite: true,
+            chromiumOptions,
+            scale: params.scale,
+            timeoutInMilliseconds: params.timeoutInMilliseconds,
+            everyNthFrame: params.everyNthFrame,
+            numberOfGifLoops: params.numberOfGifLoops,
+            muted: params.muted,
+            enforceAudioTrack: true,
+            audioBitrate: params.audioBitrate,
+            videoBitrate: params.videoBitrate,
+            encodingBufferSize: params.encodingBufferSize,
+            encodingMaxRate: params.encodingMaxRate,
+            audioCodec: params.audioCodec,
+            preferLossless: params.preferLossless,
+            browserExecutable: providerSpecifics.getChromiumPath(),
+            cancelSignal: params.enableCancellation ? cancelSignal : undefined,
+            disallowParallelEncoding: false,
+            offthreadVideoCacheSizeInBytes: params.offthreadVideoCacheSizeInBytes,
+            colorSpace: (_f = params.colorSpace) !== null && _f !== void 0 ? _f : undefined,
+            repro: false,
+            binariesDirectory: null,
+            onBrowserDownload: () => {
+                throw new Error('Should not download a browser in Lambda');
+            },
+            onArtifact: (artifact) => {
+                const registration = onArtifact({
+                    artifact,
+                    chunk: 0,
+                    attempt: 1,
+                });
+                if (registration.type === 'conflict') {
+                    throw new Error(`The artifact filename ${artifact.filename} was emitted more than once. https://remotion.dev/docs/artifacts`);
+                }
+            },
+            metadata: params.metadata,
+            hardwareAcceleration: 'disable',
+            chromeMode: 'headless-shell',
+            offthreadVideoThreads: params.offthreadVideoThreads,
+            mediaCacheSizeInBytes: params.mediaCacheSizeInBytes,
+            licenseKey: null,
+            isProduction: false,
+            sampleRate: params.sampleRate,
+            onProgress: ({ renderedFrames, encodedFrames }) => {
+                overallProgress.setFrames({
+                    index: 0,
+                    rendered: renderedFrames,
+                    encoded: encodedFrames,
+                });
+            },
+        });
+        overallProgress.setFrames({
+            index: 0,
+            rendered: frameCount,
+            encoded: frameCount,
+        });
+        overallProgress.addChunkCompleted(0, startedAt, Date.now());
+        overallProgress.setCombinedFrames(frameCount);
+        return { outputFile, cleanup };
+    }
+    catch (err) {
+        await cleanup();
+        throw err;
+    }
+    finally {
+        stopCancellationPolling();
+    }
+};
+exports.renderWithSingleFunction = renderWithSingleFunction;

package/dist/stream-renderer.d.ts

@@ -1,5 +1,5 @@
-import type { EmittedArtifact } from '@remotion/renderer';
 import type { CloudProvider, ProviderSpecifics, ServerlessPayload } from '@remotion/serverless-client';
+import type { OnArtifactFromRenderer } from './artifact-registry';
 import type { OverallProgressHelper } from './overall-render-progress';
 import type { InsideFunctionSpecifics } from './provider-implementation';
 export declare const renderRendererFunctionWithRetry: <Provider extends CloudProvider<string, Record<string, unknown>, Record<string, unknown>, string, object>>({ payload, files, functionName, outdir, overallProgress, logLevel, onArtifact, providerSpecifics, insideFunctionSpecifics, requestHandler, expectedBucketOwner, }: {
@@ -9,9 +9,7 @@ export declare const renderRendererFunctionWithRetry: <Provider extends CloudPro
     overallProgress: OverallProgressHelper<Provider>;
     files: string[];
     logLevel: "error" | "info" | "trace" | "verbose" | "warn";
-    onArtifact: (asset: EmittedArtifact) => {
-        alreadyExisted: boolean;
-    };
+    onArtifact: OnArtifactFromRenderer;
     providerSpecifics: ProviderSpecifics<Provider>;
     insideFunctionSpecifics: InsideFunctionSpecifics<Provider>;
     requestHandler: Provider["requestHandler"] | null;

package/dist/stream-renderer.js

@@ -76,14 +76,21 @@ const streamRenderer = ({ payload, functionName, outdir, overallProgress, files,
             if (message.type === 'artifact-emitted') {
                 const artifact = (0, serverless_client_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) {
+                const artifactRegistration = onArtifact({
+                    artifact,
+                    chunk: payload.chunk,
+                    attempt: payload.attempt,
+                });
+                if (artifactRegistration.type === 'conflict') {
                     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,
                     });
                 }
+                if (artifactRegistration.type === 'retry-replay') {
+                    renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Ignoring artifact ${artifact.filename} replayed by attempt ${payload.attempt} of chunk ${payload.chunk}`);
+                }
                 return;
             }
             if (message.type === 'error-occurred') {
@@ -309,14 +316,21 @@ const s3Renderer = async ({ payload, functionName, outdir, overallProgress, file
                     downloadedKeys.push(key);
                 }
                 for (const emittedArtifact of emittedArtifacts) {
-                    const { alreadyExisted } = onArtifact(emittedArtifact);
-                    if (alreadyExisted) {
+                    const artifactRegistration = onArtifact({
+                        artifact: emittedArtifact,
+                        chunk: payload.chunk,
+                        attempt: payload.attempt,
+                    });
+                    if (artifactRegistration.type === 'conflict') {
                         return {
                             type: 'error',
                             error: `Chunk ${payload.chunk} emitted an asset filename ${emittedArtifact.filename} at frame ${emittedArtifact.frame} but there is already another artifact with the same name. https://remotion.dev/docs/artifacts`,
                             shouldRetry: false,
                         };
                     }
+                    if (artifactRegistration.type === 'retry-replay') {
+                        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `Ignoring artifact ${emittedArtifact.filename} replayed by attempt ${payload.attempt} of chunk ${payload.chunk}`);
+                    }
                 }
                 files.push(...downloadedFiles);
                 overallProgress.addChunkCompleted(payload.chunk, status.startedAt, status.completedAt);

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/serverless"
 	},
 	"name": "@remotion/serverless",
-	"version": "4.0.516",
+	"version": "4.0.518",
 	"description": "A runtime for distributed rendering",
 	"main": "dist",
 	"scripts": {
@@ -23,13 +23,13 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@remotion/renderer": "4.0.516",
-		"@remotion/bundler": "4.0.516",
-		"@remotion/licensing": "4.0.516",
-		"@remotion/serverless-client": "4.0.516"
+		"@remotion/renderer": "4.0.518",
+		"@remotion/bundler": "4.0.518",
+		"@remotion/licensing": "4.0.518",
+		"@remotion/serverless-client": "4.0.518"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.516",
+		"@remotion/eslint-config-internal": "4.0.518",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},