🎥 Make videos programmatically with React
`@remotion/lambda`: Allow cancelling renders (#10653)
Jonny Burgerec4d03587018
diff --git a/packages/cli/src/cleanup-before-quit.ts b/packages/cli/src/cleanup-before-quit.tsindex 33d363769d..eb2c00fb49 100644--- a/packages/cli/src/cleanup-before-quit.ts+++ b/packages/cli/src/cleanup-before-quit.ts@@ -3,6 +3,10 @@ import {Log} from './log';const cleanupJobs: {label: string; job: () => void}[] = [];+type CtrlCHandler = () => number | Promise<number>;++let ctrlCHandler: CtrlCHandler | null = null;+export const cleanupBeforeQuit = ({indent,logLevel,@@ -24,16 +28,62 @@ export const registerCleanupJob = (label: string, job: () => void) => {cleanupJobs.push({job, label});};+export const registerCtrlCHandler = (handler: CtrlCHandler) => {+ ctrlCHandler = handler;++ return () => {+ if (ctrlCHandler === handler) {+ ctrlCHandler = null;+ }+ };+};+export const handleCtrlC = ({indent,logLevel,+ exit = process.exit,}: {indent: boolean;logLevel: LogLevel;+ exit?: (exitCode: number) => void;}) => {- process.on('SIGINT', () => {+ let handlingCtrlC = false;+ let forceExited = false;++ const listener = async () => {+ if (handlingCtrlC) {+ forceExited = true;+ exit(130);+ return;+ }++ handlingCtrlC = true;Log.info({indent: false, logLevel});+ let exitCode = 0;+ const handler = ctrlCHandler;+ ctrlCHandler = null;++ try {+ if (handler) {+ exitCode = await handler();+ }+ } catch (err) {+ Log.error(+ {indent: false, logLevel},+ err instanceof Error ? err.message : String(err),+ );+ exitCode = 1;+ }++ if (forceExited) {+ return;+ }+cleanupBeforeQuit({indent, logLevel});- process.exit(0);- });+ exit(exitCode);+ };++ process.on('SIGINT', listener);++ return () => process.removeListener('SIGINT', listener);};diff --git a/packages/cli/src/config/index.ts b/packages/cli/src/config/index.tsindex 3b081da754..71b6ae29bb 100644--- a/packages/cli/src/config/index.ts+++ b/packages/cli/src/config/index.ts@@ -98,6 +98,7 @@ const {disallowParallelEncodingOption,deleteAfterOption,folderExpiryOption,+ enableCancellationOption,enableMultiprocessOnLinuxOption,glOption,gopSizeOption,@@ -639,6 +640,10 @@ type FlatConfig = RemotionConfigObject &* Set whether S3 buckets should be allowed to expire.*/setEnableFolderExpiry: (value: boolean | null) => void;+ /**+ * Allow `npx remotion lambda render` to cancel a render when Ctrl+C is pressed.+ */+ setEnableCancellation: (value: boolean) => void;/*** Set whether Lambda Insights should be enabled when deploying a function.*/@@ -835,6 +840,7 @@ export const Config: FlatConfig = {setDisallowParallelEncoding: disallowParallelEncodingOption.setConfig,setBeepOnFinish: beepOnFinishOption.setConfig,setEnableFolderExpiry: folderExpiryOption.setConfig,+ setEnableCancellation: enableCancellationOption.setConfig,setRepro: reproOption.setConfig,setLambdaInsights: enableLambdaInsights.setConfig,setBinariesDirectory: binariesDirectoryOption.setConfig,diff --git a/packages/cli/src/index.ts b/packages/cli/src/index.tsindex 096a74103b..e66991c5a1 100644--- a/packages/cli/src/index.ts+++ b/packages/cli/src/index.ts@@ -9,7 +9,11 @@ import {defaultBrowserDownloadProgress} from './browser-download-bar';import {bundleCommand} from './bundle';import {chalk} from './chalk';import {checkForNpmRunFlagPass} from './check-for-npm-run-flag-pass';-import {cleanupBeforeQuit, handleCtrlC} from './cleanup-before-quit';+import {+ cleanupBeforeQuit,+ handleCtrlC,+ registerCtrlCHandler,+} from './cleanup-before-quit';import {cloudrunCommand} from './cloudrun-command';import {listCompositionsCommand} from './compositions';import {determineFinalStillImageFormat} from './determine-image-format';@@ -207,4 +211,6 @@ export const CliInternals = {makeHyperlink,supportsHyperlink,getGitSource,+ handleCtrlC,+ registerCtrlCHandler,};diff --git a/packages/cli/src/parsed-cli.ts b/packages/cli/src/parsed-cli.tsindex 5dd4bf7553..e767246b9c 100644--- a/packages/cli/src/parsed-cli.ts+++ b/packages/cli/src/parsed-cli.ts@@ -19,6 +19,7 @@ const {encodingMaxRateOption,deleteAfterOption,folderExpiryOption,+ enableCancellationOption,enableMultiprocessOnLinuxOption,numberOfGifLoopsOption,x264Option,@@ -190,6 +191,9 @@ export type CommandLineOptions = {[ipv4Option.cliFlag]: TypeOfOption<typeof ipv4Option> | null;[deleteAfterOption.cliFlag]: TypeOfOption<typeof deleteAfterOption>;[folderExpiryOption.cliFlag]: TypeOfOption<typeof folderExpiryOption>;+ [enableCancellationOption.cliFlag]: TypeOfOption<+ typeof enableCancellationOption+ > | null;[enableMultiprocessOnLinuxOption.cliFlag]: TypeOfOption<typeof enableMultiprocessOnLinuxOption>;@@ -232,6 +236,7 @@ export const BooleanFlags = [disableGitSourceOption.cliFlag,disallowParallelEncodingOption.cliFlag,forSeamlessAacConcatenationOption.cliFlag,+ enableCancellationOption.cliFlag,reproOption.cliFlag,isProductionOption.cliFlag,forceNewStudioOption.cliFlag,@@ -262,6 +267,7 @@ export const parsedCli = minimist<CommandLineOptions>(process.argv.slice(2), {[forceNewStudioOption.cliFlag]: null,[experimentalKeepAudioContextAliveOption.cliFlag]: null,[mutedOption.cliFlag]: null,+ [enableCancellationOption.cliFlag]: null,[rspackOption.cliFlag]: null,},}) as CommandLineOptions & {diff --git a/packages/cli/src/test/boolean-flag-defaults.test.ts b/packages/cli/src/test/boolean-flag-defaults.test.tsindex 433e545e12..0f075fda32 100644--- a/packages/cli/src/test/boolean-flag-defaults.test.ts+++ b/packages/cli/src/test/boolean-flag-defaults.test.ts@@ -6,6 +6,7 @@ const {beepOnFinishOption,disableWebSecurityOption,disallowParallelEncodingOption,+ enableCancellationOption,forceNewStudioOption,headlessOption,ignoreCertificateErrorsOption,@@ -28,6 +29,7 @@ test('config-backed boolean flags default to null when absent', () => {expect(parsedCli[ipv4Option.cliFlag]).toEqual(null);expect(parsedCli[beepOnFinishOption.cliFlag]).toEqual(null);expect(parsedCli[disallowParallelEncodingOption.cliFlag]).toEqual(null);+ expect(parsedCli[enableCancellationOption.cliFlag]).toEqual(null);expect(parsedCli[reproOption.cliFlag]).toEqual(null);expect(parsedCli[isProductionOption.cliFlag]).toEqual(null);expect(parsedCli[forceNewStudioOption.cliFlag]).toEqual(null);diff --git a/packages/cli/src/test/ctrl-c.test.ts b/packages/cli/src/test/ctrl-c.test.tsnew file mode 100644index 0000000000..cd85b70aef--- /dev/null+++ b/packages/cli/src/test/ctrl-c.test.ts@@ -0,0 +1,70 @@+import {expect, test} from 'bun:test';+import {handleCtrlC, registerCtrlCHandler} from '../cleanup-before-quit';++const waitForTask = () => new Promise((resolve) => setTimeout(resolve, 0));++test('Ctrl+C waits for a command-specific async handler', async () => {+ let releaseHandler: () => void = () => undefined;+ const waitUntilReleased = new Promise<void>((resolve) => {+ releaseHandler = resolve;+ });+ const exits: number[] = [];+ let handlerCalls = 0;+ const unregisterHandler = registerCtrlCHandler(async () => {+ handlerCalls++;+ await waitUntilReleased;+ return 130;+ });+ const unregisterListener = handleCtrlC({+ indent: false,+ logLevel: 'error',+ exit: (exitCode) => exits.push(exitCode),+ });++ try {+ process.emit('SIGINT', 'SIGINT');+ await waitForTask();+ expect(handlerCalls).toBe(1);+ expect(exits).toEqual([]);++ releaseHandler();+ await waitForTask();+ expect(exits).toEqual([130]);+ } finally {+ unregisterHandler();+ unregisterListener();+ }+});++test('a second Ctrl+C exits immediately', async () => {+ let releaseHandler: () => void = () => undefined;+ const waitUntilReleased = new Promise<void>((resolve) => {+ releaseHandler = resolve;+ });+ const exits: number[] = [];+ const unregisterHandler = registerCtrlCHandler(async () => {+ await waitUntilReleased;+ return 130;+ });+ const unregisterListener = handleCtrlC({+ indent: false,+ logLevel: 'error',+ exit: (exitCode) => exits.push(exitCode),+ });++ try {+ process.emit('SIGINT', 'SIGINT');+ await waitForTask();+ expect(exits).toEqual([]);++ process.emit('SIGINT', 'SIGINT');+ expect(exits).toEqual([130]);++ releaseHandler();+ await waitForTask();+ expect(exits).toEqual([130]);+ } finally {+ unregisterHandler();+ unregisterListener();+ }+});diff --git a/packages/docs/docs/config.mdx b/packages/docs/docs/config.mdxindex b9972721aa..8e80d6ed18 100644--- a/packages/docs/docs/config.mdx+++ b/packages/docs/docs/config.mdx@@ -966,6 +966,20 @@ import {Config} from '@remotion/cli/config';Config.setEnableFolderExpiry(true);```+## `setEnableCancellation()`<AvailableFrom v="4.0.515" />++<Options id="enable-cancellation" />+<br />+<br />++```ts twoslash title="remotion.config.ts"+import {Config} from '@remotion/cli/config';+// ---cut---+Config.setEnableCancellation(true);+```++The `--enable-cancellation` command line flag will take precedence over this option.+## `setLambdaInsights()`<AvailableFrom v="4.0.115" /><Options id="enable-lambda-insights" />diff --git a/packages/docs/docs/lambda/cancellation.mdx b/packages/docs/docs/lambda/cancellation.mdxnew file mode 100644index 0000000000..cc343cc0cc--- /dev/null+++ b/packages/docs/docs/lambda/cancellation.mdx@@ -0,0 +1,103 @@+---+image: /generated/articles-docs-lambda-cancellation.png+id: cancellation+title: Cancelling Lambda renders+sidebar_label: Cancelling renders+crumb: 'Lambda'+---++# Cancelling Lambda renders<AvailableFrom v="4.0.515" />++By default, a Lambda render continues until it finishes or fails.++To allow a render to be cancelled, polling to S3 needs to be enabled. Each active renderer then makes one S3 `HEAD` request per second.++Set [`enableCancellation`](/docs/lambda/rendermediaonlambda#enablecancellation) to `true` when calling [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda).++Still renders cannot be cancelled because [`renderStillOnLambda()`](/docs/lambda/renderstillonlambda) only returns after the still has been rendered.++```ts twoslash title="cancel-render.ts"+import {+ cancelRenderOnLambda,+ renderMediaOnLambda,+} from '@remotion/lambda/client';++const {bucketName, renderId} = await renderMediaOnLambda({+ region: 'us-east-1',+ functionName: 'remotion-render-bds9aab',+ composition: 'MyVideo',+ serveUrl: 'https://remotionlambda-qg35eyp1s1.s3.eu-central-1.amazonaws.com/sites/bf2jrbfkw',+ codec: 'h264',+ enableCancellation: true,+});++// Call this when the render should stop+await cancelRenderOnLambda({+ region: 'us-east-1',+ bucketName,+ renderId,+});+```++Calling [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda) for a render that was not started with `enableCancellation: true` throws an error.++## Cancelling from the CLI++Pass `--enable-cancellation` to [`npx remotion lambda render`](/docs/lambda/cli/render):++```bash title="Terminal"+npx remotion lambda render <serve-url> <composition-id> --enable-cancellation+```++Press Ctrl+C to send the cancellation signal. The CLI exits after the signal has been written. Press Ctrl+C again to exit immediately without waiting for the signal to be written.++Without `--enable-cancellation`, pressing Ctrl+C stops the CLI from waiting, but the Lambda render continues.++## Cost++Cancellation is opt-in because each [renderer function](/docs/lambda/how-lambda-works) checks S3 once per second for a cancellation signal.++Each renderer makes approximately one additional S3 `HEAD` request for every second that it is active. Renderer functions stop polling when they finish or receive the cancellation signal.++In the absolute worst case of 200 concurrent functions running for the full 15-minute Lambda limit, polling costs approximately $0.072.++These estimates use the current US East (N. Virginia) ARM list prices and exclude the AWS Free Tier and volume discounts. Prices vary by region. See [AWS Lambda pricing](https://aws.amazon.com/lambda/pricing/) and [Amazon S3 pricing](https://aws.amazon.com/s3/pricing/).++Leave `enableCancellation` at its default value of `false` if the render does not need to be cancellable.++## How cancellation works++[`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda) writes a cancellation signal to S3. Renderer functions stop after seeing the signal during their next poll.++:::note+Cancellation is asynchronous. The promise returned by `cancelRenderOnLambda()` resolves once the signal has been written, not once every renderer function has stopped.+:::++If the main function fails or times out, it also sends the cancellation signal to the remaining renderer functions.++Cancelling a render does not delete its files from S3. After cancellation has propagated, use [`deleteRender()`](/docs/lambda/deleterender) to remove them. If the render has already finished, cancelling it does not remove or invalidate the output file.++## Detecting a cancelled render++There is currently no dedicated `cancelled` field. A renderer that receives the cancellation signal adds a fatal error named `CancelledError` to the render progress.++```ts twoslash title="detect-cancellation.ts"+import type {RenderProgress} from '@remotion/lambda/client';++export const wasRenderCancelled = (progress: RenderProgress) => {+ return progress.errors.some((error) => error.name === 'CancelledError');+};+```++In the value returned by [`getRenderProgress()`](/docs/lambda/getrenderprogress), `fatalErrorEncountered` will also be `true`, while `done` remains `false`.++The same `errors` array is stored in `progress.json`, so checking for `CancelledError` also works when reading the file directly. `fatalErrorEncountered` is derived by `getRenderProgress()` and is not stored in `progress.json`.++If the main function fails or times out, the remaining renderer functions may also report `CancelledError`. The error indicates that a renderer received the cancellation signal, but not why the signal was sent.++## See also++- [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda)+- [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda)+- [`getRenderProgress()`](/docs/lambda/getrenderprogress)+- [How Remotion Lambda works](/docs/lambda/how-lambda-works)diff --git a/packages/docs/docs/lambda/cancelrenderonlambda.mdx b/packages/docs/docs/lambda/cancelrenderonlambda.mdxnew file mode 100644index 0000000000..907e521f4d--- /dev/null+++ b/packages/docs/docs/lambda/cancelrenderonlambda.mdx@@ -0,0 +1,77 @@+---+image: /generated/articles-docs-lambda-cancelrenderonlambda.png+id: cancelrenderonlambda+title: cancelRenderOnLambda()+crumb: '@remotion/lambda-client'+---++# cancelRenderOnLambda()<AvailableFrom v="4.0.515" />++Signals the renderer functions of an in-progress Lambda render to stop.++The render must have been started with [`enableCancellation: true`](/docs/lambda/rendermediaonlambda#enablecancellation). Otherwise, this function throws an error.++## Example++```ts twoslash title="cancel-render.ts"+import {+ cancelRenderOnLambda,+ renderMediaOnLambda,+} from '@remotion/lambda/client';++const {bucketName, renderId} = await renderMediaOnLambda({+ region: 'us-east-1',+ functionName: 'remotion-render-bds9aab',+ composition: 'MyVideo',+ serveUrl: 'https://remotionlambda-qg35eyp1s1.s3.eu-central-1.amazonaws.com/sites/bf2jrbfkw',+ codec: 'h264',+ enableCancellation: true,+});++await cancelRenderOnLambda({+ region: 'us-east-1',+ bucketName,+ renderId,+});+```++Cancellation is asynchronous. Renderer functions stop after their next S3 poll, which occurs once per second.++## Arguments++An object with the following properties:++### `region`++The [AWS region](/docs/lambda/region-selection) in which the render is running.++### `bucketName`++The bucket name returned by [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda).++### `renderId`++The render ID returned by [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda).++### `forcePathStyle?`++Passes `forcePathStyle` to the AWS S3 client. If you don't know what this is, you probably don't need it.++### `requestHandler?`++An AWS SDK request handler. Use it to configure a [proxy](/docs/lambda/proxy).++## Return value++A promise that resolves when the cancellation signal has been written to S3.++## Compatibility++<CompatibilityTable chrome={false} firefox={false} safari={false} nodejs={true} bun={true} serverlessFunctions={true} clientSideRendering={false} serverSideRendering={false} player={false} studio={false} />++## See also++- [Cancelling Lambda renders](/docs/lambda/cancellation)+- [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda)+- [`getRenderProgress()`](/docs/lambda/getrenderprogress)+- [Source code for this function](https://github.com/remotion-dev/remotion/blob/main/packages/lambda-client/src/cancel-render-on-lambda.ts)diff --git a/packages/docs/docs/lambda/cli/render.mdx b/packages/docs/docs/lambda/cli/render.mdxindex 3803115570..d899b97f2d 100644--- a/packages/docs/docs/lambda/cli/render.mdx+++ b/packages/docs/docs/lambda/cli/render.mdx@@ -77,6 +77,12 @@ npx remotion lambda render --codec=mp3 testbed my-compThe [AWS region](/docs/lambda/region-selection) to select. Both project and function should be in this region.+### `--enable-cancellation`<AvailableFrom v="4.0.515" />++<Options id="enable-cancellation" />++Press Ctrl+C to cancel the render. Without this flag, Ctrl+C stops the CLI from waiting while the Lambda render continues.+### `--props`<Options id="props" />diff --git a/packages/docs/docs/lambda/go.mdx b/packages/docs/docs/lambda/go.mdxindex 230d7d9d1e..d46c9e49b4 100644--- a/packages/docs/docs/lambda/go.mdx+++ b/packages/docs/docs/lambda/go.mdx@@ -116,6 +116,32 @@ func main() {}```+## Cancelling a render<AvailableFrom v="4.0.515" />++Set `EnableCancellation` when starting the render, then pass its response to `CancelRenderOnLambda()`:++```go title="cancel-render.go"+renderResponse, err := lambda_go_sdk.RenderMediaOnLambda(lambda_go_sdk.RemotionOptions{+ ServeUrl: serveUrl,+ FunctionName: functionName,+ Region: region,+ Composition: "main",+ EnableCancellation: true,+})+if err != nil {+ log.Fatal(err)+}++err = lambda_go_sdk.CancelRenderOnLambda(lambda_go_sdk.CancelRenderOnLambdaInput{+ Region: region,+ BucketName: renderResponse.BucketName,+ RenderId: renderResponse.RenderId,+})+if err != nil {+ log.Fatal(err)+}+```+## Changelog`v4.0.6`: The response payload structure has changed. See the history of this page to see the previous structure.diff --git a/packages/docs/docs/lambda/php.mdx b/packages/docs/docs/lambda/php.mdxindex d4733b9c80..c8dbc28bcc 100644--- a/packages/docs/docs/lambda/php.mdx+++ b/packages/docs/docs/lambda/php.mdx@@ -87,6 +87,22 @@ while (!$renderProgressResponse->done) {print_r("Render is done!\n");```+## Cancelling a render<AvailableFrom v="4.0.515" />++Enable cancellation before starting the render, then call `cancelRenderOnLambda()`:++```php title="cancel-render.php"+$params = new RenderParams(enableCancellation: true);+$params->setComposition('react-svg');++$renderResponse = $client->renderMediaOnLambda($params);++$client->cancelRenderOnLambda(+ $renderResponse->renderId,+ $renderResponse->bucketName+);+```+## Changelog- `v4.0.15`: The fields are now typed. `->setInputProps()` now works as intended, serializing the input props to JSON for you.diff --git a/packages/docs/docs/lambda/python.mdx b/packages/docs/docs/lambda/python.mdxindex 2b83af8d48..dfd3a38533 100644--- a/packages/docs/docs/lambda/python.mdx+++ b/packages/docs/docs/lambda/python.mdx@@ -82,6 +82,24 @@ if render_response:print("Render done!", progress_response.outputFile)```+## Cancelling a render<AvailableFrom v="4.0.515" />++Enable cancellation before starting the render, then call `cancel_render_on_lambda()`:++```python title="cancel_render.py"+render_params = RenderMediaParams(+ composition="react-svg",+ enable_cancellation=True,+)+render_response = client.render_media_on_lambda(render_params)++if render_response:+ client.cancel_render_on_lambda(+ render_id=render_response.render_id,+ bucket_name=render_response.bucket_name,+ )+```+## Large input props _available from v4.0.315_The Python SDK automatically handles large input props by uploading them to S3 when they exceed AWS Lambda payload limits:diff --git a/packages/docs/docs/lambda/rendermediaonlambda.mdx b/packages/docs/docs/lambda/rendermediaonlambda.mdxindex 85692610f0..208657fa46 100644--- a/packages/docs/docs/lambda/rendermediaonlambda.mdx+++ b/packages/docs/docs/lambda/rendermediaonlambda.mdx@@ -69,6 +69,14 @@ The `framesPerLambda` parameter cannot result in more than 200 functions being sWhen rendering transparent WebM videos, chunk boundaries can be visible in the alpha channel. See [Known problem: Rendering transparent WebM on Lambda](/docs/transparent-videos#known-problem-rendering-transparent-webm-on-lambda). Increase `framesPerLambda` to reduce boundaries, or render WebM in one pass if the artifact appears.:::+### `enableCancellation?`<AvailableFrom v="4.0.515" />++Enable the render to be cancelled using [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda). Default: `false`.++When enabled, every renderer checks S3 once per second for a cancellation signal. This incurs additional S3 `HEAD` request charges for the duration of the render.++See [Cancelling Lambda renders](/docs/lambda/cancellation) for the full workflow.+### `concurrency?`<AvailableFrom v="4.0.322" />Specify the number of Lambda functions to use for rendering. This is an alternative to `framesPerLambda` that allows you to set the concurrency directly without needing to know the video duration.diff --git a/packages/docs/docs/lambda/ruby.mdx b/packages/docs/docs/lambda/ruby.mdxindex 4c31aa3011..f937b45eb5 100644--- a/packages/docs/docs/lambda/ruby.mdx+++ b/packages/docs/docs/lambda/ruby.mdx@@ -14,7 +14,7 @@ The version should be the same version of the `@remotion/lambda` NPM package ver## Notes- This module is experimental and might have breaking changes in minor versions. Check on this page for up-to-date examples.-- The implemented methods are [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda), [`renderStillOnLambda()`](/docs/lambda/renderstillonlambda) and [`getRenderProgressOnLambda()`](/docs/lambda/getrenderprogress).+- The implemented methods are [`renderMediaOnLambda()`](/docs/lambda/rendermediaonlambda), [`renderStillOnLambda()`](/docs/lambda/renderstillonlambda), [`getRenderProgressOnLambda()`](/docs/lambda/getrenderprogress), and [`cancelRenderOnLambda()`](/docs/lambda/cancelrenderonlambda).- We will maintain the Ruby SDK to ensure the fields stay in sync with the Node.js functions.- The fields in the input payload are `snake_case` versions of the Node.js field names.- Nested field names, e.g. `s3_output_provder.accessKeyId` have the original `camelCase` capitalization.@@ -58,6 +58,21 @@ while trueend```+## Cancelling a render<AvailableFrom v="4.0.515" />++Enable cancellation in the render payload, then call `cancel_render_on_lambda()`:++```ruby title="Cancelling a render from Ruby"+payload = get_render_media_on_lambda_payload(+ composition: "still-helloworld",+ codec: "h264",+ enable_cancellation: true,+)++res = client.render_media_on_lambda(function_name, payload)+client.cancel_render_on_lambda(res["bucketName"], res["renderId"])+```+## Rendering a still```ruby title="Rendering a still from Ruby"diff --git a/packages/docs/docs/lambda/table-of-contents.tsx b/packages/docs/docs/lambda/table-of-contents.tsxindex 54cf5c02d9..719fac0919 100644--- a/packages/docs/docs/lambda/table-of-contents.tsx+++ b/packages/docs/docs/lambda/table-of-contents.tsx@@ -58,6 +58,10 @@ export const TableOfContents: React.FC = () => {<strong>downloadMedia()</strong><div>Download a render artifact from S3</div></TOCItem>+ <TOCItem link="/docs/lambda/cancelrenderonlambda">+ <strong>cancelRenderOnLambda()</strong>+ <div>Cancel an in-progress render</div>+ </TOCItem><TOCItem link="/docs/lambda/getuserpolicy"><strong>getUserPolicy()</strong><div>Get the policy JSON for your AWS user</div>diff --git a/packages/docs/sidebars.ts b/packages/docs/sidebars.tsindex f42ad1b54b..8f0aa55c91 100644--- a/packages/docs/sidebars.ts+++ b/packages/docs/sidebars.ts@@ -445,6 +445,7 @@ const sidebars: SidebarsConfig = {'lambda/getrenderprogress','lambda/presignurl','lambda/rendermediaonlambda',+ 'lambda/cancelrenderonlambda','lambda/renderstillonlambda','lambda/simulatepermissions','lambda/speculatefunctionname',@@ -1289,6 +1290,7 @@ const sidebars: SidebarsConfig = {'lambda/custom-destination','lambda/checklist','lambda/webhooks',+ 'lambda/cancellation','lambda/cost-example','lambda/autodelete',{diff --git a/packages/docs/src/data/articles.ts b/packages/docs/src/data/articles.tsindex 8a78d07622..c0ce3e96ca 100644--- a/packages/docs/src/data/articles.ts+++ b/packages/docs/src/data/articles.ts@@ -3077,6 +3077,24 @@ export const articles = [noAi: false,slug: 'lambda/bucket-security',},+ {+ id: 'cancellation',+ title: 'Cancelling Lambda renders',+ relativePath: 'docs/lambda/cancellation.mdx',+ compId: 'articles-docs-lambda-cancellation',+ crumb: 'Lambda',+ noAi: false,+ slug: 'lambda/cancellation',+ },+ {+ id: 'cancelrenderonlambda',+ title: 'cancelRenderOnLambda()',+ relativePath: 'docs/lambda/cancelrenderonlambda.mdx',+ compId: 'articles-docs-lambda-cancelrenderonlambda',+ crumb: '@remotion/lambda-client',+ noAi: false,+ slug: 'lambda/cancelrenderonlambda',+ },{id: 'changelog',title: 'Prerelease Changelog',diff --git a/packages/docs/static/generated/articles-docs-lambda-cancellation.png b/packages/docs/static/generated/articles-docs-lambda-cancellation.pngnew file mode 100644index 0000000000..21ff8370a6Binary files /dev/null and b/packages/docs/static/generated/articles-docs-lambda-cancellation.png differdiff --git a/packages/docs/static/generated/articles-docs-lambda-cancelrenderonlambda.png b/packages/docs/static/generated/articles-docs-lambda-cancelrenderonlambda.pngnew file mode 100644index 0000000000..2378a32a42Binary files /dev/null and b/packages/docs/static/generated/articles-docs-lambda-cancelrenderonlambda.png differdiff --git a/packages/it-tests/src/monorepo/esm.test.ts b/packages/it-tests/src/monorepo/esm.test.tsindex 3ad328e283..a6913bbad9 100644--- a/packages/it-tests/src/monorepo/esm.test.ts+++ b/packages/it-tests/src/monorepo/esm.test.ts@@ -33,6 +33,9 @@ test('Should be able to "import" frontend in node', async () => {execSync(`node --input-type=module -e "import {getRenderProgress} from '@remotion/lambda/client'; console.log(getRenderProgress)"`,);+ execSync(+ `node --input-type=module -e "import {cancelRenderOnLambda} from '@remotion/lambda/client'; console.log(cancelRenderOnLambda)"`,+ );execSync(`node --input-type=module -e "import {getRenderProgress} from '@remotion/lambda'; console.log(getRenderProgress)"`,);diff --git a/packages/it-tests/src/monorepo/go-package.test.ts b/packages/it-tests/src/monorepo/go-package.test.tsindex 5a6532e2e0..371556a8dd 100644--- a/packages/it-tests/src/monorepo/go-package.test.ts+++ b/packages/it-tests/src/monorepo/go-package.test.ts@@ -32,6 +32,7 @@ test(const nativeVersion =await LambdaClientInternals.makeLambdaRenderMediaPayload({+ enableCancellation: false,region: 'us-east-1',composition: 'react-svg',functionName: 'remotion-render',diff --git a/packages/it-tests/src/monorepo/php-package.test.ts b/packages/it-tests/src/monorepo/php-package.test.tsindex 1465d2d968..e3045c62a6 100644--- a/packages/it-tests/src/monorepo/php-package.test.ts+++ b/packages/it-tests/src/monorepo/php-package.test.ts@@ -97,6 +97,7 @@ class Semanticconst toParse = output[5];const nativeVersion =await LambdaClientInternals.makeLambdaRenderMediaPayload({+ enableCancellation: false,region: 'us-east-1',composition: 'react-svg',functionName: 'remotion-render',diff --git a/packages/it-tests/src/monorepo/python-package.test.ts b/packages/it-tests/src/monorepo/python-package.test.tsindex 73f81f3210..a917985a99 100644--- a/packages/it-tests/src/monorepo/python-package.test.ts+++ b/packages/it-tests/src/monorepo/python-package.test.ts@@ -49,6 +49,7 @@ test('Python package should create the same renderMedia payload as normal Lambdaconst toParse = output[PYTHON_OUTPUT_MARKER];const nativeVersion =await LambdaClientInternals.makeLambdaRenderMediaPayload({+ enableCancellation: false,requestHandler: null,region: 'us-east-1',composition: 'react-svg',diff --git a/packages/it-tests/src/monorepo/ruby-package.test.ts b/packages/it-tests/src/monorepo/ruby-package.test.tsindex 1778547ed4..c878aca311 100644--- a/packages/it-tests/src/monorepo/ruby-package.test.ts+++ b/packages/it-tests/src/monorepo/ruby-package.test.ts@@ -75,6 +75,7 @@ test('Render Media payload', async () => {const nativeVersion =await LambdaClientInternals.makeLambdaRenderMediaPayload({+ enableCancellation: false,region: 'us-east-1',composition: 'react-svg',functionName: 'remotion-render',diff --git a/packages/lambda-client/src/cancel-render-on-lambda.ts b/packages/lambda-client/src/cancel-render-on-lambda.tsnew file mode 100644index 0000000000..ce66a43274--- /dev/null+++ b/packages/lambda-client/src/cancel-render-on-lambda.ts@@ -0,0 +1,73 @@+import type {ProviderSpecifics} from '@remotion/serverless-client';+import {+ getOverallProgressFromStorage,+ writeCancellationSignal,+} from '@remotion/serverless-client';+import {awsImplementation, type AwsProvider} from './aws-provider';+import type {AwsRegion} from './regions';+import type {RequestHandler} from './types';++export type CancelRenderOnLambdaInput = {+ region: AwsRegion;+ bucketName: string;+ renderId: string;+ forcePathStyle?: boolean;+ requestHandler?: RequestHandler;+};++type InternalCancelRenderOnLambdaInput = Omit<+ CancelRenderOnLambdaInput,+ 'forcePathStyle' | 'requestHandler'+> & {+ forcePathStyle: boolean;+ requestHandler: RequestHandler | null;+ providerSpecifics: ProviderSpecifics<AwsProvider>;+};++export const internalCancelRenderOnLambda = async (+ input: InternalCancelRenderOnLambdaInput,+): Promise<void> => {+ const expectedBucketOwner = await input.providerSpecifics.getAccountId({+ region: input.region,+ });+ const progress = await getOverallProgressFromStorage({+ bucketName: input.bucketName,+ expectedBucketOwner,+ region: input.region,+ renderId: input.renderId,+ providerSpecifics: input.providerSpecifics,+ forcePathStyle: input.forcePathStyle,+ requestHandler: input.requestHandler,+ });++ if (progress.cancellationEnabled !== true) {+ throw new Error(+ `Cannot cancel render ${input.renderId}: The render was not started with enableCancellation: true.`,+ );+ }++ await writeCancellationSignal({+ bucketName: input.bucketName,+ renderId: input.renderId,+ region: input.region,+ expectedBucketOwner,+ providerSpecifics: input.providerSpecifics,+ forcePathStyle: input.forcePathStyle,+ requestHandler: input.requestHandler,+ });+};++/*+ * @description Cancels an in-progress render that was started with enableCancellation: true.+ * @see [Documentation](https://remotion.dev/docs/lambda/cancelrenderonlambda)+ */+export const cancelRenderOnLambda = (+ input: CancelRenderOnLambdaInput,+): Promise<void> => {+ return internalCancelRenderOnLambda({+ ...input,+ forcePathStyle: input.forcePathStyle ?? false,+ requestHandler: input.requestHandler ?? null,+ providerSpecifics: awsImplementation,+ });+};diff --git a/packages/lambda-client/src/index.ts b/packages/lambda-client/src/index.tsindex 9e92eab1d1..c1df53ab9b 100644--- a/packages/lambda-client/src/index.ts+++ b/packages/lambda-client/src/index.ts@@ -17,6 +17,7 @@ import {getAwsRegionMetadata,} from './aws-region-metadata';import {parseJsonOrThrowSource} from './call-lambda-streaming';+import {internalCancelRenderOnLambda} from './cancel-render-on-lambda';import {cleanItems} from './clean-items';import {DEFAULT_CLOUDWATCH_RETENTION_PERIOD,@@ -73,6 +74,10 @@ export type {} from '@remotion/serverless-client';export {appRouterWebhook, NextWebhookArgs} from './app-router-webhook';export {AwsProvider} from './aws-provider';+export {+ cancelRenderOnLambda,+ type CancelRenderOnLambdaInput,+} from './cancel-render-on-lambda';export type {AwsBillingCurrency,AwsPartition,@@ -142,6 +147,7 @@ export const LambdaClientInternals: {makeLambdaRenderMediaPayload: typeof makeLambdaRenderMediaPayload;renderMediaOnLambdaOptionalToRequired: typeof renderMediaOnLambdaOptionalToRequired;internalDeleteRender: typeof internalDeleteRender;+ internalCancelRenderOnLambda: typeof internalCancelRenderOnLambda;internalGetSites: typeof internalGetSites;getLifeCycleRules: typeof getLifeCycleRules;awsImplementation: typeof awsImplementation;@@ -187,6 +193,7 @@ export const LambdaClientInternals: {makeLambdaRenderMediaPayload,renderMediaOnLambdaOptionalToRequired,internalDeleteRender,+ internalCancelRenderOnLambda,internalGetSites,getLifeCycleRules,awsImplementation,diff --git a/packages/lambda-client/src/make-lambda-payload.ts b/packages/lambda-client/src/make-lambda-payload.tsindex 214261e8bf..0a645203d2 100644--- a/packages/lambda-client/src/make-lambda-payload.ts+++ b/packages/lambda-client/src/make-lambda-payload.ts@@ -41,6 +41,7 @@ import {validateLambdaCodec} from './validate-lambda-codec';import {validateServeUrl} from './validate-serveurl';export type InnerRenderMediaOnLambdaInput = {+ enableCancellation: boolean;region: AwsRegion;functionName: string;serveUrl: string;@@ -96,6 +97,7 @@ export type InnerRenderMediaOnLambdaInput = {>;export const makeLambdaRenderMediaPayload = async ({+ enableCancellation,rendererFunctionName,frameRange,framesPerLambda,@@ -183,6 +185,7 @@ export const makeLambdaRenderMediaPayload = async ({logLevel,});return {+ enableCancellation,rendererFunctionName,framesPerLambda,concurrency,diff --git a/packages/lambda-client/src/render-media-on-lambda.ts b/packages/lambda-client/src/render-media-on-lambda.tsindex f7e5ea2ccf..a937137268 100644--- a/packages/lambda-client/src/render-media-on-lambda.ts+++ b/packages/lambda-client/src/render-media-on-lambda.ts@@ -32,6 +32,7 @@ import type {AwsRegion} from './regions';import type {RequestHandler} from './types';export type RenderMediaOnLambdaInput = {+ enableCancellation?: boolean;region: AwsRegion;functionName: string;serveUrl: string;@@ -160,6 +161,7 @@ export const renderMediaOnLambdaOptionalToRequired = (options: RenderMediaOnLambdaInput,): InnerRenderMediaOnLambdaInput => {return {+ enableCancellation: options.enableCancellation ?? false,offthreadVideoThreads: options.offthreadVideoThreads ?? null,audioBitrate: options.audioBitrate ?? null,audioCodec: options.audioCodec ?? null,diff --git a/packages/lambda-client/src/test/cancel-render-on-lambda.test.ts b/packages/lambda-client/src/test/cancel-render-on-lambda.test.tsnew file mode 100644index 0000000000..60462de112--- /dev/null+++ b/packages/lambda-client/src/test/cancel-render-on-lambda.test.ts@@ -0,0 +1,84 @@+import {expect, test} from 'bun:test';+import {Readable} from 'node:stream';+import {+ cancellationKey,+ overallProgressKey,+ type ProviderSpecifics,+} from '@remotion/serverless-client';+import {awsImplementation, type AwsProvider} from '../aws-provider';+import {internalCancelRenderOnLambda} from '../cancel-render-on-lambda';++const makeProviderSpecifics = ({+ cancellationEnabled,+ onWrite,+}: {+ cancellationEnabled: boolean | undefined;+ onWrite: ProviderSpecifics<AwsProvider>['writeFile'];+}): ProviderSpecifics<AwsProvider> => {+ return {+ ...awsImplementation,+ getAccountId: () => Promise.resolve('123456789012'),+ readFile: ({key}) => {+ expect(key).toBe(overallProgressKey('render-id'));+ return Promise.resolve(+ Readable.from([+ Buffer.from(+ JSON.stringify({+ cancellationEnabled,+ }),+ ),+ ]),+ );+ },+ writeFile: onWrite,+ };+};++test('writes a cancellation signal for an opted-in render', async () => {+ let writes = 0;+ const providerSpecifics = makeProviderSpecifics({+ cancellationEnabled: true,+ onWrite: (input) => {+ writes++;+ expect(input.bucketName).toBe('bucket');+ expect(input.key).toBe(cancellationKey('render-id'));+ expect(input.privacy).toBe('private');+ expect(JSON.parse(String(input.body)).cancelledAt).toBeNumber();+ return Promise.resolve();+ },+ });++ await internalCancelRenderOnLambda({+ bucketName: 'bucket',+ renderId: 'render-id',+ region: 'us-east-1',+ forcePathStyle: false,+ requestHandler: null,+ providerSpecifics,+ });++ expect(writes).toBe(1);+});++test('rejects cancellation if the render did not opt in', async () => {+ let writes = 0;+ const providerSpecifics = makeProviderSpecifics({+ cancellationEnabled: undefined,+ onWrite: () => {+ writes++;+ return Promise.resolve();+ },+ });++ await expect(+ internalCancelRenderOnLambda({+ bucketName: 'bucket',+ renderId: 'render-id',+ region: 'us-east-1',+ forcePathStyle: false,+ requestHandler: null,+ providerSpecifics,+ }),+ ).rejects.toThrow('enableCancellation: true');+ expect(writes).toBe(0);+});diff --git a/packages/lambda-client/src/test/concurrency-payload.test.ts b/packages/lambda-client/src/test/concurrency-payload.test.tsindex c33c74cae7..6048db471f 100644--- a/packages/lambda-client/src/test/concurrency-payload.test.ts+++ b/packages/lambda-client/src/test/concurrency-payload.test.ts@@ -4,6 +4,7 @@ import {makeLambdaRenderMediaPayload} from '../make-lambda-payload';test('Should include concurrency field in payload', async () => {const payload = await makeLambdaRenderMediaPayload({+ enableCancellation: false,region: 'us-east-1',functionName: 'test-function',serveUrl: 'https://example.com',@@ -68,6 +69,7 @@ test('Should include concurrency field in payload', async () => {test('Should handle null concurrency', async () => {const payload = await makeLambdaRenderMediaPayload({+ enableCancellation: false,region: 'us-east-1',functionName: 'test-function',serveUrl: 'https://example.com',diff --git a/packages/lambda-client/src/test/overwrite-default.test.ts b/packages/lambda-client/src/test/overwrite-default.test.tsindex 5c5cdcbe73..ab2c2c24ef 100644--- a/packages/lambda-client/src/test/overwrite-default.test.ts+++ b/packages/lambda-client/src/test/overwrite-default.test.ts@@ -15,6 +15,18 @@ test('keeps an omitted overwrite value unresolved', () => {const options = renderMediaOnLambdaOptionalToRequired(getOptions());expect(options.overwrite).toBeUndefined();+ expect(options.enableCancellation).toBe(false);+});++test('preserves enableCancellation in the Lambda payload', async () => {+ const options = renderMediaOnLambdaOptionalToRequired({+ ...getOptions(),+ enableCancellation: true,+ });++ expect(options.enableCancellation).toBe(true);+ const payload = await makeLambdaRenderMediaPayload(options);+ expect(payload.enableCancellation).toBe(true);});test('preserves an explicit overwrite value', () => {diff --git a/packages/lambda-go/internalops.go b/packages/lambda-go/internalops.goindex c8aca4e037..cea3296cf9 100644--- a/packages/lambda-go/internalops.go+++ b/packages/lambda-go/internalops.go@@ -26,6 +26,7 @@ func constructRenderInternals(options *RemotionOptions) (*renderInternalOptions,}internalParams := renderInternalOptions{+ EnableCancellation: options.EnableCancellation,ServeUrl: options.ServeUrl,InputProps: inputProps,Composition: options.Composition,diff --git a/packages/lambda-go/lambda_go_sdk.go b/packages/lambda-go/lambda_go_sdk.goindex 4e0b22fb28..c53ce968d1 100644--- a/packages/lambda-go/lambda_go_sdk.go+++ b/packages/lambda-go/lambda_go_sdk.go@@ -1,5 +1,7 @@package lambda_go_sdk+import "github.com/go-playground/validator/v10"+func RenderMediaOnLambda(input RemotionOptions) (*RemotionRenderResponse, error) {return invokeRenderLambda(input)}@@ -7,3 +9,17 @@ func RenderMediaOnLambda(input RemotionOptions) (*RemotionRenderResponse, error)func GetRenderProgress(input RenderConfig) (*RenderProgress, error) {return invokeRenderProgressLambda(input)}++func CancelRenderOnLambda(input CancelRenderOnLambdaInput) error {+ validate := validator.New()+ if err := validate.Struct(input); err != nil {+ return err+ }++ s3Client, err := newS3Client(input.Region, input.ForcePathStyle)+ if err != nil {+ return err+ }++ return cancelRenderOnLambda(s3Client, input)+}diff --git a/packages/lambda-go/lambda_go_sdk_test.go b/packages/lambda-go/lambda_go_sdk_test.goindex 3166187479..97576302c3 100644--- a/packages/lambda-go/lambda_go_sdk_test.go+++ b/packages/lambda-go/lambda_go_sdk_test.go@@ -34,6 +34,30 @@ type objectUploaderMock struct {err error}+type cancellationObjectClientMock struct {+ progress string+ getInput *s3.GetObjectInput+ putInput *s3.PutObjectInput+}++func (mock *cancellationObjectClientMock) GetObject(+ _ context.Context,+ input *s3.GetObjectInput,+ _ ...func(*s3.Options),+) (*s3.GetObjectOutput, error) {+ mock.getInput = input+ return &s3.GetObjectOutput{Body: io.NopCloser(strings.NewReader(mock.progress))}, nil+}++func (mock *cancellationObjectClientMock) PutObject(+ _ context.Context,+ input *s3.PutObjectInput,+ _ ...func(*s3.Options),+) (*s3.PutObjectOutput, error) {+ mock.putInput = input+ return &s3.PutObjectOutput{}, nil+}+func (mock *objectUploaderMock) PutObject(_ context.Context,input *s3.PutObjectInput,@@ -66,6 +90,45 @@ func TestPrintVersion(t *testing.T) {println(string(jsonData))}+func TestCancelRenderOnLambda(t *testing.T) {+ client := &cancellationObjectClientMock{progress: `{"cancellationEnabled":true}`}+ input := CancelRenderOnLambdaInput{+ Region: "us-east-1",+ BucketName: "remotionlambda-test",+ RenderId: "render-id",+ }++ if err := cancelRenderOnLambda(client, input); err != nil {+ t.Fatalf("could not cancel render: %v", err)+ }+ if aws.ToString(client.getInput.Key) != "renders/render-id/progress.json" {+ t.Fatalf("unexpected progress key: %s", aws.ToString(client.getInput.Key))+ }+ if aws.ToString(client.putInput.Key) != "renders/render-id/cancel.json" {+ t.Fatalf("unexpected cancellation key: %s", aws.ToString(client.putInput.Key))+ }+ body, err := io.ReadAll(client.putInput.Body)+ if err != nil {+ t.Fatalf("could not read cancellation body: %v", err)+ }+ var cancellationBody map[string]int64+ if err := json.Unmarshal(body, &cancellationBody); err != nil {+ t.Fatalf("could not parse cancellation body: %v", err)+ }+ if cancellationBody["cancelledAt"] <= 0 {+ t.Fatalf("expected cancelledAt timestamp, got %s", string(body))+ }++ disabledClient := &cancellationObjectClientMock{progress: `{}`}+ err = cancelRenderOnLambda(disabledClient, input)+ if err == nil || !strings.Contains(err.Error(), "enableCancellation: true") {+ t.Fatalf("expected cancellation opt-in error, got %v", err)+ }+ if disabledClient.putInput != nil {+ t.Fatal("should not write a cancellation signal for a disabled render")+ }+}+func TestRenderPayloadNumberOfGifLoops(t *testing.T) {tests := []struct {name stringdiff --git a/packages/lambda-go/models.go b/packages/lambda-go/models.goindex 62674b6212..0e5c55a916 100644--- a/packages/lambda-go/models.go+++ b/packages/lambda-go/models.go@@ -1,6 +1,7 @@package lambda_go_sdktype RemotionOptions struct {+ EnableCancellation bool `json:"enableCancellation"`ServeUrl string `json:"serveUrl" validate:"required"`FunctionName string `json:"functionName" validate:"required"`RendererFunctionName string `json:"rendererFunctionName"`@@ -58,6 +59,7 @@ type RemotionOptions struct {}type renderInternalOptions struct {+ EnableCancellation bool `json:"enableCancellation"`RendererFunctionName *string `json:"rendererFunctionName"`FramesPerLambda *string `json:"framesPerLambda"`Composition string `json:"composition" validate:"required"`@@ -138,6 +140,13 @@ type RenderConfig struct {ForcePathStyle bool `json:"forcePathStyle"`}+type CancelRenderOnLambdaInput struct {+ RenderId string `json:"renderId" validate:"required"`+ BucketName string `json:"bucketName" validate:"required"`+ Region string `json:"region" validate:"required"`+ ForcePathStyle bool `json:"forcePathStyle"`+}+type renderProgressInternalConfig struct {RenderId string `json:"renderId" validate:"required"`BucketName string `json:"bucketName" validate:"required"`diff --git a/packages/lambda-go/s3.go b/packages/lambda-go/s3.goindex 6da37ae49f..a093a5bf5f 100644--- a/packages/lambda-go/s3.go+++ b/packages/lambda-go/s3.go@@ -5,10 +5,13 @@ import ("crypto/rand""crypto/sha256""encoding/hex"+ "encoding/json""errors""fmt"+ "io""math/big""strings"+ "time""github.com/aws/aws-sdk-go-v2/aws""github.com/aws/aws-sdk-go-v2/config"@@ -28,6 +31,11 @@ type objectUploader interface {PutObject(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)}+type cancellationObjectClient interface {+ GetObject(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)+ PutObject(context.Context, *s3.PutObjectInput, ...func(*s3.Options)) (*s3.PutObjectOutput, error)+}+// hashPayload returns the SHA256 hex digest used as the input-props object name.func hashPayload(payload string) string {sum := sha256.Sum256([]byte(payload))@@ -61,6 +69,56 @@ func inputPropsKey(hash string) string {return fmt.Sprintf("input-props/%s.json", hash)}+func overallProgressKey(renderId string) string {+ return fmt.Sprintf("renders/%s/progress.json", renderId)+}++func cancellationKey(renderId string) string {+ return fmt.Sprintf("renders/%s/cancel.json", renderId)+}++func cancelRenderOnLambda(client cancellationObjectClient, input CancelRenderOnLambdaInput) error {+ progressObject, err := client.GetObject(context.TODO(), &s3.GetObjectInput{+ Bucket: new(input.BucketName),+ Key: new(overallProgressKey(input.RenderId)),+ })+ if err != nil {+ return fmt.Errorf("could not read progress for render %q: %w", input.RenderId, err)+ }+ defer progressObject.Body.Close()++ progressBody, err := io.ReadAll(progressObject.Body)+ if err != nil {+ return fmt.Errorf("could not read progress for render %q: %w", input.RenderId, err)+ }++ var progress struct {+ CancellationEnabled bool `json:"cancellationEnabled"`+ }+ if err := json.Unmarshal(progressBody, &progress); err != nil {+ return fmt.Errorf("could not parse progress for render %q: %w", input.RenderId, err)+ }+ if !progress.CancellationEnabled {+ return fmt.Errorf("cannot cancel render %s: the render was not started with enableCancellation: true", input.RenderId)+ }++ cancellationBody, err := json.Marshal(map[string]int64{"cancelledAt": time.Now().UnixMilli()})+ if err != nil {+ return fmt.Errorf("could not serialize cancellation signal: %w", err)+ }+ _, err = client.PutObject(context.TODO(), &s3.PutObjectInput{+ Bucket: new(input.BucketName),+ Key: new(cancellationKey(input.RenderId)),+ Body: strings.NewReader(string(cancellationBody)),+ ContentType: new("application/json"),+ })+ if err != nil {+ return fmt.Errorf("could not cancel render %q: %w", input.RenderId, err)+ }++ return nil+}+// newS3Client creates an S3 client using the same shared config resolution as// the Lambda client in invocations.go.func newS3Client(region string, forcePathStyle bool) (*s3.Client, error) {diff --git a/packages/lambda-php/src/PHPClient.php b/packages/lambda-php/src/PHPClient.phpindex 83d4438582..ffe792696c 100644--- a/packages/lambda-php/src/PHPClient.php+++ b/packages/lambda-php/src/PHPClient.php@@ -294,6 +294,59 @@ class PHPClientreturn $this->handleLambdaResponseProgress($result);}+ public function cancelRenderOnLambda(string $renderId, string $bucketName): void+ {+ try {+ $progress = json_decode(+ $this->readProgressFromS3($bucketName, "renders/{$renderId}/progress.json"),+ true,+ 512,+ JSON_THROW_ON_ERROR+ );+ } catch (\Throwable $exception) {+ throw new Exception("Could not read progress for render {$renderId}: {$exception->getMessage()}", 0, $exception);+ }++ if (($progress['cancellationEnabled'] ?? false) !== true) {+ throw new InvalidArgumentException(+ "Cannot cancel render {$renderId}: The render was not started with enableCancellation: true."+ );+ }++ try {+ $this->writeCancellationToS3(+ $bucketName,+ "renders/{$renderId}/cancel.json",+ json_encode(+ ['cancelledAt' => (int) floor(microtime(true) * 1000)],+ JSON_THROW_ON_ERROR+ )+ );+ } catch (\Throwable $exception) {+ throw new Exception("Could not cancel render {$renderId}: {$exception->getMessage()}", 0, $exception);+ }+ }++ protected function readProgressFromS3(string $bucketName, string $key): string+ {+ $result = $this->createS3Client()->getObject([+ 'Bucket' => $bucketName,+ 'Key' => $key,+ ]);++ return (string) $result['Body'];+ }++ protected function writeCancellationToS3(string $bucketName, string $key, string $body): void+ {+ $this->createS3Client()->putObject([+ 'Bucket' => $bucketName,+ 'Key' => $key,+ 'Body' => $body,+ 'ContentType' => 'application/json',+ ]);+ }+private function invokeLambdaFunction(string $payload){$result = $this->client->invoke([diff --git a/packages/lambda-php/src/RenderParams.php b/packages/lambda-php/src/RenderParams.phpindex 7ca8fcdce4..b5327f02f9 100644--- a/packages/lambda-php/src/RenderParams.php+++ b/packages/lambda-php/src/RenderParams.php@@ -6,6 +6,7 @@ use stdClass;class RenderParams{+ protected $enableCancellation = false;protected $data = null;protected $bucketName = null;protected $region = null;@@ -114,7 +115,8 @@ class RenderParams?bool $forcePathStyle = false,?array $metadata = null,?bool $isProduction = null,- ?int $gopSize = null+ ?int $gopSize = null,+ ?bool $enableCancellation = false){if ($chromiumOptions === null) {@@ -171,6 +173,7 @@ class RenderParams$this->forcePathStyle = $forcePathStyle;$this->isProduction = $isProduction;$this->gopSize = $gopSize;+ $this->enableCancellation = $enableCancellation;}private array $inputProps = array();@@ -178,6 +181,7 @@ class RenderParamspublic function serializeParams(){$parameters = [+ 'enableCancellation' => $this->getEnableCancellation(),'rendererFunctionName' => $this->getRendererFunctionName(),'framesPerLambda' => $this->getFramesPerLambda(),'composition' => $this->getComposition(),@@ -274,6 +278,18 @@ class RenderParamsreturn $parameters;}+ public function getEnableCancellation()+ {+ return $this->enableCancellation;+ }++ public function setEnableCancellation($enableCancellation)+ {+ $this->enableCancellation = $enableCancellation;++ return $this;+ }+public function getForcePathStyle(){return $this->forcePathStyle;diff --git a/packages/lambda-php/tests/PHPClientTest.php b/packages/lambda-php/tests/PHPClientTest.phpindex 00294c71c8..6a0dc784d7 100644--- a/packages/lambda-php/tests/PHPClientTest.php+++ b/packages/lambda-php/tests/PHPClientTest.php@@ -6,6 +6,26 @@ use PHPUnit\Framework\TestCase;use Remotion\LambdaPhp\PHPClient;use Remotion\LambdaPhp\RenderParams;+class CancellationPHPClient extends PHPClient+{+ public array $writes = [];+ public bool $cancellationEnabled = true;++ public function __construct()+ {+ }++ protected function readProgressFromS3(string $bucketName, string $key): string+ {+ return json_encode(['cancellationEnabled' => $this->cancellationEnabled]);+ }++ protected function writeCancellationToS3(string $bucketName, string $key, string $body): void+ {+ $this->writes[] = compact('bucketName', 'key', 'body');+ }+}+class PHPClientTest extends TestCase{public function testOverwriteDefaultsToFalseInV4()@@ -14,6 +34,31 @@ class PHPClientTest extends TestCase$this->assertFalse($params->getOverwrite());$this->assertFalse($params->serializeParams()['overwrite']);+ $this->assertFalse($params->serializeParams()['enableCancellation']);+ }++ public function testEnableCancellationAndCancelRender()+ {+ $params = new RenderParams(enableCancellation: true);+ $this->assertTrue($params->serializeParams()['enableCancellation']);++ $client = new CancellationPHPClient();+ $client->cancelRenderOnLambda('render-id', 'remotionlambda-test');++ $this->assertCount(1, $client->writes);+ $this->assertEquals('remotionlambda-test', $client->writes[0]['bucketName']);+ $this->assertEquals('renders/render-id/cancel.json', $client->writes[0]['key']);+ $this->assertGreaterThan(0, json_decode($client->writes[0]['body'], true)['cancelledAt']);+ }++ public function testCancelRenderRequiresOptIn()+ {+ $client = new CancellationPHPClient();+ $client->cancellationEnabled = false;++ $this->expectException(\InvalidArgumentException::class);+ $this->expectExceptionMessage('enableCancellation: true');+ $client->cancelRenderOnLambda('render-id', 'remotionlambda-test');}public function testExplicitOverwriteValueIsPreserved()diff --git a/packages/lambda-python/remotion_lambda/models.py b/packages/lambda-python/remotion_lambda/models.pyindex be038b12fb..bdae181518 100644--- a/packages/lambda-python/remotion_lambda/models.py+++ b/packages/lambda-python/remotion_lambda/models.py@@ -282,6 +282,7 @@ class RenderMediaParams:region: Optional[str] = Noneout_name: Optional[Union[str, OutNameInputObject]] = Noneprefer_lossless: Optional[bool] = False+ enable_cancellation: bool = Falsecomposition: str = ""serve_url: str = ""frames_per_lambda: Optional[int] = None@@ -342,6 +343,7 @@ class RenderMediaParams:Convert instance attributes to a dictionary for serialization."""parameters = {+ 'enableCancellation': self.enable_cancellation,'rendererFunctionName': self.renderer_function_name,'framesPerLambda': self.frames_per_lambda,'concurrency': self.concurrency,diff --git a/packages/lambda-python/remotion_lambda/remotionclient.py b/packages/lambda-python/remotion_lambda/remotionclient.pyindex 266efb83a9..9ba127cb1d 100644--- a/packages/lambda-python/remotion_lambda/remotionclient.py+++ b/packages/lambda-python/remotion_lambda/remotionclient.py@@ -4,6 +4,7 @@ from dataclasses import asdictimport randomimport jsonimport hashlib+import timefrom math import ceilfrom typing import Optional, Union, List, Dict, Anyfrom enum import Enum@@ -626,6 +627,38 @@ class RemotionClient:return None+ def cancel_render_on_lambda(self, render_id: str, bucket_name: str) -> None:+ """Cancel a render started with ``enable_cancellation=True``."""+ s3_client = self._create_s3_client()+ try:+ progress_object = s3_client.get_object(+ Bucket=bucket_name,+ Key=f"renders/{render_id}/progress.json",+ )+ progress = json.loads(progress_object['Body'].read())+ except (ClientError, KeyError, TypeError, json.JSONDecodeError) as error:+ raise RemotionException(+ f"Could not read progress for render {render_id}: {error}"+ ) from error++ if progress.get('cancellationEnabled') is not True:+ raise RemotionInvalidArgumentException(+ f"Cannot cancel render {render_id}: The render was not started "+ "with enableCancellation: true."+ )++ try:+ s3_client.put_object(+ Bucket=bucket_name,+ Key=f"renders/{render_id}/cancel.json",+ Body=json.dumps({'cancelledAt': int(time.time() * 1000)}),+ ContentType='application/json',+ )+ except ClientError as error:+ raise RemotionException(+ f"Could not cancel render {render_id}: {error}"+ ) from error+def render_still_on_lambda(self, render_params: RenderStillParams) -> Optional[RenderStillResponse]:diff --git a/packages/lambda-python/tests/test_render_client_render_media.py b/packages/lambda-python/tests/test_render_client_render_media.pyindex 673f505a24..911eee2886 100644--- a/packages/lambda-python/tests/test_render_client_render_media.py+++ b/packages/lambda-python/tests/test_render_client_render_media.py@@ -1,5 +1,6 @@+import jsonfrom unittest import TestCase-from unittest.mock import patch+from unittest.mock import Mock, patchfrom remotion_lambda.models import RenderMediaParams, ShouldDownload, Webhookfrom remotion_lambda.remotionclient import RemotionClient@@ -11,6 +12,46 @@ class TestRemotionClient(TestCase):render_params = RenderMediaParams()self.assertFalse(render_params.serialize_params()['overwrite'])+ self.assertFalse(render_params.serialize_params()['enableCancellation'])++ def test_enable_cancellation_is_serialized(self):+ render_params = RenderMediaParams(enable_cancellation=True)++ self.assertTrue(render_params.serialize_params()['enableCancellation'])++ def test_cancel_render_on_lambda(self):+ client = RemotionClient(+ region="us-east-1", serve_url="testbed", function_name="remotion-render"+ )+ s3_client = Mock()+ s3_client.get_object.return_value = {+ 'Body': Mock(read=Mock(return_value=b'{"cancellationEnabled": true}'))+ }+ client._create_s3_client = Mock(return_value=s3_client)++ client.cancel_render_on_lambda('render-id', 'remotionlambda-test')++ s3_client.get_object.assert_called_once_with(+ Bucket='remotionlambda-test', Key='renders/render-id/progress.json'+ )+ put_input = s3_client.put_object.call_args.kwargs+ self.assertEqual(put_input['Key'], 'renders/render-id/cancel.json')+ self.assertGreater(json.loads(put_input['Body'])['cancelledAt'], 0)++ def test_cancel_render_requires_opt_in(self):+ client = RemotionClient(+ region="us-east-1", serve_url="testbed", function_name="remotion-render"+ )+ s3_client = Mock()+ s3_client.get_object.return_value = {'Body': Mock(read=Mock(return_value=b'{}'))}+ client._create_s3_client = Mock(return_value=s3_client)++ with self.assertRaisesRegex(+ RemotionInvalidArgumentException, 'enableCancellation: true'+ ):+ client.cancel_render_on_lambda('render-id', 'remotionlambda-test')++ s3_client.put_object.assert_not_called()@patch('remotion_lambda.models.VERSION', '5.0.0')def test_overwrite_defaults_to_true_in_v5(self):diff --git a/packages/lambda-ruby/Gemfile b/packages/lambda-ruby/Gemfileindex 1be56368af..a84f40d77b 100644--- a/packages/lambda-ruby/Gemfile+++ b/packages/lambda-ruby/Gemfile@@ -1,5 +1,7 @@source 'https://rubygems.org'gem 'aws-sdk-lambda', '1.143.0'+gem 'aws-sdk-s3', '1.183.0'gem 'json', '2.8.2'gem 'logger', '1.6.1'+gem 'rexml', '3.4.4'diff --git a/packages/lambda-ruby/Gemfile.lock b/packages/lambda-ruby/Gemfile.lockindex 40a99c38e3..5fce4c7059 100644--- a/packages/lambda-ruby/Gemfile.lock+++ b/packages/lambda-ruby/Gemfile.lock@@ -3,27 +3,42 @@ GEMspecs:aws-eventstream (1.3.0)aws-partitions (1.1012.0)- aws-sdk-core (3.213.0)+ aws-sdk-core (3.254.1)aws-eventstream (~> 1, >= 1.3.0)aws-partitions (~> 1, >= 1.992.0)aws-sigv4 (~> 1.9)+ base64+ bigdecimaljmespath (~> 1, >= 1.6.1)+ logger+ aws-sdk-kms (1.130.0)+ aws-sdk-core (~> 3, >= 3.254.0)+ aws-sigv4 (~> 1.5)aws-sdk-lambda (1.143.0)aws-sdk-core (~> 3, >= 3.210.0)aws-sigv4 (~> 1.5)+ aws-sdk-s3 (1.183.0)+ aws-sdk-core (~> 3, >= 3.216.0)+ aws-sdk-kms (~> 1)+ aws-sigv4 (~> 1.5)aws-sigv4 (1.10.1)aws-eventstream (~> 1, >= 1.0.2)+ base64 (0.3.0)+ bigdecimal (4.1.2)jmespath (1.6.2)json (2.8.2)logger (1.6.1)+ rexml (3.4.4)PLATFORMSrubyDEPENDENCIESaws-sdk-lambda (= 1.143.0)+ aws-sdk-s3 (= 1.183.0)json (= 2.8.2)logger (= 1.6.1)+ rexml (= 3.4.4)BUNDLED WITH2.6.9diff --git a/packages/lambda-ruby/lib/remotion_lambda/cancel_render_on_lambda_spec.rb b/packages/lambda-ruby/lib/remotion_lambda/cancel_render_on_lambda_spec.rbnew file mode 100644index 0000000000..332edb64ec--- /dev/null+++ b/packages/lambda-ruby/lib/remotion_lambda/cancel_render_on_lambda_spec.rb@@ -0,0 +1,26 @@+require_relative 'sdk'+require 'aws-sdk-s3'+require 'json'++s3_client = Aws::S3::Client.new(stub_responses: true)+s3_client.stub_responses(:get_object, body: JSON.generate(cancellationEnabled: true))+client = RemotionLambda::Client.new(s3_client: s3_client)++client.cancel_render_on_lambda('remotionlambda-test', 'render-id')++requests = s3_client.api_requests+raise 'Expected progress to be read' unless requests[0][:params][:key] == 'renders/render-id/progress.json'+raise 'Expected cancellation signal to be written' unless requests[1][:params][:key] == 'renders/render-id/cancel.json'+cancellation_body = JSON.parse(requests[1][:params][:body])+raise 'Expected cancelledAt timestamp' unless cancellation_body['cancelledAt'] > 0++disabled_s3_client = Aws::S3::Client.new(stub_responses: true)+disabled_s3_client.stub_responses(:get_object, body: '{}')+disabled_client = RemotionLambda::Client.new(s3_client: disabled_s3_client)++begin+ disabled_client.cancel_render_on_lambda('remotionlambda-test', 'render-id')+ raise 'Expected cancellation to fail without opt-in'+rescue => error+ raise error unless error.message.include?('enableCancellation: true')+enddiff --git a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rb b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rbindex 70b243681e..24ef0cf8b6 100644--- a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rb+++ b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload.rb@@ -19,6 +19,7 @@ def get_render_media_on_lambda_payload(crf: nil,delete_after: nil,download_behavior: nil,+ enable_cancellation: false,encoding_buffer_size: nil,encoding_max_rate: nil,env_variables: {},@@ -79,6 +80,7 @@ payload = {crf: crf,deleteAfter: delete_after,downloadBehavior: download_behavior,+ enableCancellation: enable_cancellation,encodingBufferSize: encoding_buffer_size,encodingMaxRate: encoding_max_rate,envVariables: env_variables,diff --git a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rb b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rbindex 27e2a4044f..258a7e5910 100644--- a/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rb+++ b/packages/lambda-ruby/lib/remotion_lambda/render_media_on_lambda_payload_spec.rb@@ -30,6 +30,10 @@ payload = get_render_media_on_lambda_payload()raise "Expected the current SDK to default overwrite to false" unless payload[:overwrite] == false+raise "Expected cancellation to default to false" unless payload[:enableCancellation] == false++cancellable_payload = get_render_media_on_lambda_payload(codec: "h264", enable_cancellation: true)+raise "Expected cancellation to be enabled" unless cancellable_payload[:enableCancellation] == true# Print as JSONputs JSON.generate(payload)diff --git a/packages/lambda-ruby/lib/remotion_lambda/sdk.rb b/packages/lambda-ruby/lib/remotion_lambda/sdk.rbindex d7f2ad6486..ee35317035 100644--- a/packages/lambda-ruby/lib/remotion_lambda/sdk.rb+++ b/packages/lambda-ruby/lib/remotion_lambda/sdk.rb@@ -1,4 +1,5 @@require 'aws-sdk-lambda'+require 'aws-sdk-s3'require 'json'require 'logger'require_relative 'version'@@ -9,11 +10,13 @@ module RemotionLambdadef initialize(region: ENV.fetch('AWS_REGION', 'us-east-1'),- aws_profile: nil+ aws_profile: nil,+ s3_client: nil)@region = region@aws_profile = aws_profile@lambda_client = create_lambda_client+ @s3_client = s3_clientenddef get_render_progress(function_name, payload)@@ -34,6 +37,26 @@ module RemotionLambdabodyend+ def cancel_render_on_lambda(bucket_name, render_id)+ progress_response = s3_client.get_object(+ bucket: bucket_name,+ key: "renders/#{render_id}/progress.json"+ )+ progress = JSON.parse(progress_response.body.read)++ unless progress['cancellationEnabled'] == true+ raise "Cannot cancel render #{render_id}: The render was not started with enableCancellation: true."+ end++ s3_client.put_object(+ bucket: bucket_name,+ key: "renders/#{render_id}/cancel.json",+ body: JSON.generate(cancelledAt: (Time.now.to_f * 1000).floor),+ content_type: 'application/json'+ )+ nil+ end+private# Lambda methods@@ -50,6 +73,10 @@ module RemotionLambdaAws::Lambda::Client.new(region: @region, credentials: aws_credentials)end+ def s3_client+ @s3_client ||= Aws::S3::Client.new(region: @region, credentials: aws_credentials)+ end+def aws_credentialsif @aws_profileAws::SharedCredentials.new(profile_name: @aws_profile)diff --git a/packages/lambda-ruby/remotion_lambda.gemspec b/packages/lambda-ruby/remotion_lambda.gemspecindex 46b65e5d0e..181121132d 100644--- a/packages/lambda-ruby/remotion_lambda.gemspec+++ b/packages/lambda-ruby/remotion_lambda.gemspec@@ -11,8 +11,12 @@ Gem::Specification.new do |s|s.license = "MIT"s.add_runtime_dependency "aws-sdk-lambda",["> 1.0.0"]+ s.add_runtime_dependency "aws-sdk-s3",+ ["> 1.0.0"]s.add_runtime_dependency "json",["> 2.0.0"]s.add_runtime_dependency "logger",["> 1.0.0"]+ s.add_runtime_dependency "rexml",+ ["> 3.0.0"]enddiff --git a/packages/lambda/src/cli/commands/render/render.ts b/packages/lambda/src/cli/commands/render/render.tsindex 160f25eea6..15dfb52775 100644--- a/packages/lambda/src/cli/commands/render/render.ts+++ b/packages/lambda/src/cli/commands/render/render.ts@@ -78,6 +78,7 @@ const {overrideFpsOption,overrideDurationOption,sampleRateOption,+ enableCancellationOption,} = BrowserSafeApis.options;export const renderCommand = async ({@@ -124,6 +125,9 @@ export const renderCommand = async ({}const singleFrameRange = frameRange as SingleFrameRange | null;+ const enableCancellation = enableCancellationOption.getValue({+ commandLine: CliInternals.parsedCli,+ }).value;const height = overrideHeightOption.getValue({commandLine: CliInternals.parsedCli,@@ -382,6 +386,7 @@ export const renderCommand = async ({const webhookCustomData = getWebhookCustomData(logLevel);const res = await LambdaClientInternals.internalRenderMediaOnLambdaRaw({+ enableCancellation,functionName,serveUrl,inputProps,@@ -449,6 +454,45 @@ export const renderCommand = async ({sampleRate,});+ const unregisterCtrlCHandler = CliInternals.registerCtrlCHandler(async () => {+ if (!enableCancellation) {+ Log.info(+ {indent: false, logLevel},+ 'Stopped waiting. The Lambda render is still running.',+ );+ Log.info(+ {indent: false, logLevel},+ 'Use --enable-cancellation to allow Ctrl+C to cancel it.',+ );+ return 130;+ }++ Log.info({indent: false, logLevel}, 'Cancelling Lambda render...');+ try {+ await LambdaClientInternals.internalCancelRenderOnLambda({+ bucketName: res.bucketName,+ region,+ renderId: res.renderId,+ forcePathStyle: parsedLambdaCli['force-path-style'] ?? false,+ requestHandler: null,+ providerSpecifics,+ });+ } catch (err) {+ Log.error(+ {indent: false, logLevel},+ `Could not cancel the Lambda render: ${err instanceof Error ? err.message : String(err)}`,+ );+ Log.info(+ {indent: false, logLevel},+ 'The Lambda render may still be running.',+ );+ return 1;+ }++ Log.info({indent: false, logLevel}, 'Cancellation signal sent.');+ return 130;+ });+const progressBar = CliInternals.createOverwriteableCliOutput({quiet: CliInternals.quietFlagProvided(),cancelSignal: null,@@ -464,6 +508,12 @@ export const renderCommand = async ({`Bucket: ${CliInternals.makeHyperlink({text: res.bucketName, fallback: res.bucketName, url: LambdaClientInternals.getS3BucketUrl({region: getAwsRegion(), bucketName: res.bucketName})})}`,),);+ if (enableCancellation) {+ Log.info(+ {indent: false, logLevel},+ CliInternals.chalk.gray('Press Ctrl+C to cancel the render.'),+ );+ }Log.info({indent: false, logLevel},CliInternals.chalk.gray(@@ -577,6 +627,7 @@ export const renderCommand = async ({);if (newStatus.done) {+ unregisterCtrlCHandler();let downloadOrNothing;if (downloadName) {@@ -688,6 +739,7 @@ export const renderCommand = async ({}if (newStatus.fatalErrorEncountered) {+ unregisterCtrlCHandler();Log.error({indent: false, logLevel}, '\n');const uniqueErrors: EnhancedErrorInfo[] = [];for (const err of newStatus.errors) {diff --git a/packages/lambda/src/test/integration/cli-render-cancellation.test.ts b/packages/lambda/src/test/integration/cli-render-cancellation.test.tsnew file mode 100644index 0000000000..22dfa765b6--- /dev/null+++ b/packages/lambda/src/test/integration/cli-render-cancellation.test.ts@@ -0,0 +1,177 @@+import {afterEach, beforeEach, expect, test} from 'bun:test';+import {Readable} from 'node:stream';+// eslint-disable-next-line no-restricted-imports+import {CliInternals} from '@remotion/cli';+import {LambdaClientInternals} from '@remotion/lambda-client';+import {parsedLambdaCli} from '../../cli/args';+import {renderCommand} from '../../cli/commands/render/render';+import {mockImplementation} from '../mocks/mock-implementation';+import {doAfter, doBefore, getProcessWriteOutput} from './console-hooks';++const enableCancellationOption = CliInternals.parsedCli['enable-cancellation'];+const originalCallFunctionSync =+ LambdaClientInternals.awsImplementation.callFunctionSync;+const originalFunctionName = parsedLambdaCli['function-name'];+const originalRegion = parsedLambdaCli.region;++beforeEach(() => {+ doBefore();+ CliInternals.parsedCli['enable-cancellation'] = true;+ parsedLambdaCli['function-name'] = 'custom-function';+ parsedLambdaCli.region = 'us-east-1';+});++afterEach(() => {+ LambdaClientInternals.awsImplementation.callFunctionSync =+ originalCallFunctionSync;+ CliInternals.parsedCli['enable-cancellation'] = enableCancellationOption;+ parsedLambdaCli['function-name'] = originalFunctionName;+ parsedLambdaCli.region = originalRegion;+ doAfter();+});++test('Ctrl+C cancels an opted-in Lambda CLI render', async () => {+ let resolveStatusRequested: () => void = () => undefined;+ const statusRequested = new Promise<void>((resolve) => {+ resolveStatusRequested = resolve;+ });+ const pendingStatus = new Promise<never>(() => undefined);+ const enableCancellationInPayloads: boolean[] = [];++ LambdaClientInternals.awsImplementation.callFunctionSync = ((input) => {+ if (input.type === 'start') {+ enableCancellationInPayloads.push(+ (input.payload as {enableCancellation: boolean}).enableCancellation,+ );+ return Promise.resolve({bucketName: 'bucket', renderId: 'render-id'});+ }++ if (input.type === 'status') {+ resolveStatusRequested();+ return pendingStatus;+ }++ return Promise.reject(+ new Error(`Unexpected Lambda routine: ${input.type}`),+ );+ }) as typeof originalCallFunctionSync;++ let cancellationWrites = 0;+ const providerSpecifics = {+ ...mockImplementation,+ readFile: ({key}: {key: string}) => {+ expect(key).toBe('renders/render-id/progress.json');+ return Promise.resolve(+ Readable.from([+ Buffer.from(JSON.stringify({cancellationEnabled: true})),+ ]),+ );+ },+ writeFile: (input: {key: string}) => {+ expect(input.key).toBe('renders/render-id/cancel.json');+ cancellationWrites++;+ return Promise.resolve();+ },+ } as typeof mockImplementation;++ let resolveExit: (exitCode: number) => void = () => undefined;+ const exitCode = new Promise<number>((resolve) => {+ resolveExit = resolve;+ });+ const unregisterCtrlC = CliInternals.handleCtrlC({+ indent: false,+ logLevel: 'info',+ exit: resolveExit,+ });++ renderCommand({+ args: ['https://example.com', 'composition-id'],+ remotionRoot: process.cwd(),+ logLevel: 'info',+ providerSpecifics,+ }).catch(() => undefined);++ try {+ await statusRequested;+ process.emit('SIGINT', 'SIGINT');++ expect(await exitCode).toBe(130);+ expect(enableCancellationInPayloads).toEqual([true]);+ expect(cancellationWrites).toBe(1);+ expect(getProcessWriteOutput()).toContain('Cancelling Lambda render...');+ expect(getProcessWriteOutput()).toContain('Cancellation signal sent.');+ } finally {+ unregisterCtrlC();+ }+});++test('Ctrl+C leaves a Lambda CLI render running without the flag', async () => {+ CliInternals.parsedCli['enable-cancellation'] = false;+ let resolveStatusRequested: () => void = () => undefined;+ const statusRequested = new Promise<void>((resolve) => {+ resolveStatusRequested = resolve;+ });+ const pendingStatus = new Promise<never>(() => undefined);+ const enableCancellationInPayloads: boolean[] = [];++ LambdaClientInternals.awsImplementation.callFunctionSync = ((input) => {+ if (input.type === 'start') {+ enableCancellationInPayloads.push(+ (input.payload as {enableCancellation: boolean}).enableCancellation,+ );+ return Promise.resolve({bucketName: 'bucket', renderId: 'render-id'});+ }++ if (input.type === 'status') {+ resolveStatusRequested();+ return pendingStatus;+ }++ return Promise.reject(+ new Error(`Unexpected Lambda routine: ${input.type}`),+ );+ }) as typeof originalCallFunctionSync;++ let cancellationWrites = 0;+ const providerSpecifics = {+ ...mockImplementation,+ writeFile: () => {+ cancellationWrites++;+ return Promise.resolve();+ },+ } as typeof mockImplementation;++ let resolveExit: (exitCode: number) => void = () => undefined;+ const exitCode = new Promise<number>((resolve) => {+ resolveExit = resolve;+ });+ const unregisterCtrlC = CliInternals.handleCtrlC({+ indent: false,+ logLevel: 'info',+ exit: resolveExit,+ });++ renderCommand({+ args: ['https://example.com', 'composition-id'],+ remotionRoot: process.cwd(),+ logLevel: 'info',+ providerSpecifics,+ }).catch(() => undefined);++ try {+ await statusRequested;+ process.emit('SIGINT', 'SIGINT');++ expect(await exitCode).toBe(130);+ expect(enableCancellationInPayloads).toEqual([false]);+ expect(cancellationWrites).toBe(0);+ expect(getProcessWriteOutput()).toContain(+ 'Stopped waiting. The Lambda render is still running.',+ );+ expect(getProcessWriteOutput()).toContain(+ 'Use --enable-cancellation to allow Ctrl+C to cancel it.',+ );+ } finally {+ unregisterCtrlC();+ }+});diff --git a/packages/lambda/src/test/integration/renders/old-version.test.ts b/packages/lambda/src/test/integration/renders/old-version.test.tsindex e675f72799..6d57a51ce5 100644--- a/packages/lambda/src/test/integration/renders/old-version.test.ts+++ b/packages/lambda/src/test/integration/renders/old-version.test.ts@@ -10,6 +10,7 @@ test(const aha = await mockImplementation.callFunctionSync({type: ServerlessRoutines.launch,payload: {+ enableCancellation: false,type: ServerlessRoutines.launch,serveUrl: path.join(__dirname, 'old-version-bundle'),chromiumOptions: {},diff --git a/packages/lambda/src/test/integration/webhooks.test.ts b/packages/lambda/src/test/integration/webhooks.test.tsindex 3522ea6b27..5341fe9420 100644--- a/packages/lambda/src/test/integration/webhooks.test.ts+++ b/packages/lambda/src/test/integration/webhooks.test.ts@@ -37,6 +37,7 @@ test(const res = await mockImplementation.callFunctionSync({type: ServerlessRoutines.start,payload: {+ enableCancellation: false,type: ServerlessRoutines.start,serveUrl: `http://localhost:${port}`,chromiumOptions: {},@@ -165,6 +166,7 @@ test(region: 'us-east-1',type: ServerlessRoutines.launch,payload: {+ enableCancellation: false,type: ServerlessRoutines.launch,mediaCacheSizeInBytes: null,offthreadVideoCacheSizeInBytes: null,diff --git a/packages/lambda/src/test/unit/x264-preset-default.test.ts b/packages/lambda/src/test/unit/x264-preset-default.test.tsindex dfeb2251be..776c8368e1 100644--- a/packages/lambda/src/test/unit/x264-preset-default.test.ts+++ b/packages/lambda/src/test/unit/x264-preset-default.test.ts@@ -65,6 +65,7 @@ const makeStartPayload = ({colorSpace: null,preferLossless: false,forcePathStyle: false,+ enableCancellation: null,metadata: null,licenseKey: null,storageClass: null,diff --git a/packages/renderer/src/options/enable-cancellation.tsx b/packages/renderer/src/options/enable-cancellation.tsxnew file mode 100644index 0000000000..b06ec2bd72--- /dev/null+++ b/packages/renderer/src/options/enable-cancellation.tsx@@ -0,0 +1,38 @@+import type {AnyRemotionOption} from './option';++const cliFlag = 'enable-cancellation' as const;++let enableCancellation = false;++export const enableCancellationOption = {+ name: 'Enable cancellation',+ cliFlag,+ description: () => (+ <>+ Allows a Lambda render to be cancelled by pressing Ctrl+C while running{' '}+ <code>npx remotion lambda render</code>. Enabling cancellation causes each+ renderer function to poll S3 once per second while it is running.+ </>+ ),+ ssrName: null,+ docLink:+ 'https://www.remotion.dev/docs/lambda/cli/render#--enable-cancellation',+ type: false as boolean,+ setConfig: (value: boolean) => {+ enableCancellation = value;+ },+ getValue: ({commandLine}) => {+ if (typeof commandLine[cliFlag] === 'boolean') {+ return {+ value: commandLine[cliFlag],+ source: 'cli',+ };+ }++ return {+ value: enableCancellation,+ source: enableCancellation ? 'config' : 'default',+ };+ },+ id: cliFlag,+} satisfies AnyRemotionOption<boolean>;diff --git a/packages/renderer/src/options/index.tsx b/packages/renderer/src/options/index.tsxindex cff91ca488..e4c9a38328 100644--- a/packages/renderer/src/options/index.tsx+++ b/packages/renderer/src/options/index.tsx@@ -22,6 +22,7 @@ import {deleteAfterOption} from './delete-after';import {disableGitSourceOption} from './disable-git-source';import {disableWebSecurityOption} from './disable-web-security';import {disallowParallelEncodingOption} from './disallow-parallel-encoding';+import {enableCancellationOption} from './enable-cancellation';import {enableLambdaInsights} from './enable-lambda-insights';import {enableMultiprocessOnLinuxOption} from './enable-multiprocess-on-linux';import {encodingBufferSizeOption} from './encoding-buffer-size';@@ -118,6 +119,7 @@ export const allOptions = {disableWebSecurityOption,disallowParallelEncodingOption,folderExpiryOption,+ enableCancellationOption,enableMultiprocessOnLinuxOption,glOption,gopSizeOption,diff --git a/packages/renderer/src/test/boolean-option-precedence.test.ts b/packages/renderer/src/test/boolean-option-precedence.test.tsindex 82784fa1e6..63f60fddcf 100644--- a/packages/renderer/src/test/boolean-option-precedence.test.ts+++ b/packages/renderer/src/test/boolean-option-precedence.test.ts@@ -2,6 +2,7 @@ import {expect, test} from 'bun:test';import {beepOnFinishOption} from '../options/beep-on-finish';import {disableWebSecurityOption} from '../options/disable-web-security';import {disallowParallelEncodingOption} from '../options/disallow-parallel-encoding';+import {enableCancellationOption} from '../options/enable-cancellation';import {forceNewStudioOption} from '../options/force-new-studio';import {headlessOption} from '../options/headless';import {ignoreCertificateErrorsOption} from '../options/ignore-certificate-errors';@@ -109,6 +110,19 @@ test('boolean options respect config if CLI flag is absent', () => {).toEqual(false);disallowParallelEncodingOption.setConfig(false);+ enableCancellationOption.setConfig(true);+ expect(+ enableCancellationOption.getValue({+ commandLine: {'enable-cancellation': null},+ }).value,+ ).toEqual(true);+ expect(+ enableCancellationOption.getValue({+ commandLine: {'enable-cancellation': false},+ }).value,+ ).toEqual(false);+ enableCancellationOption.setConfig(false);+reproOption.setConfig(true);expect(reproOption.getValue({commandLine: {repro: null}}).value).toEqual(true,diff --git a/packages/serverless-client/src/constants.ts b/packages/serverless-client/src/constants.tsindex 9a050f98d5..97fee29cff 100644--- a/packages/serverless-client/src/constants.ts+++ b/packages/serverless-client/src/constants.ts@@ -111,6 +111,7 @@ export type ServerlessStatusPayload<Provider extends CloudProvider> = {};export type ServerlessStartPayload<Provider extends CloudProvider> = {+ enableCancellation: boolean | null;rendererFunctionName: string | null;type: ServerlessRoutines.start;serveUrl: string;@@ -174,6 +175,7 @@ export type ServerlessPayloads<Provider extends CloudProvider> = {};start: ServerlessStartPayload<Provider>;launch: {+ enableCancellation: boolean | null;rendererFunctionName: string | null;type: ServerlessRoutines.launch;serveUrl: string;@@ -232,6 +234,7 @@ export type ServerlessPayloads<Provider extends CloudProvider> = {};status: ServerlessStatusPayload<Provider>;renderer: {+ enableCancellation: boolean | null;concurrencyPerLambda: number;type: ServerlessRoutines.renderer;serveUrl: string;@@ -382,6 +385,9 @@ export const customOutName = <Provider extends CloudProvider>(export const overallProgressKey = (renderId: string) =>`${rendersPrefix(renderId)}/progress.json`;+export const cancellationKey = (renderId: string) =>+ `${rendersPrefix(renderId)}/cancel.json`;+export const artifactName = (renderId: string, name: string) =>`${rendersPrefix(renderId)}/artifacts/${name}`;diff --git a/packages/serverless-client/src/index.ts b/packages/serverless-client/src/index.tsindex 9d0c590003..f66046a2cf 100644--- a/packages/serverless-client/src/index.ts+++ b/packages/serverless-client/src/index.ts@@ -2,6 +2,7 @@ import {interpolate, NoReactInternals, random} from 'remotion/no-react';export * from './constants';export {artifactName,+ cancellationKey,customOutName,expiryDays,MINIMUM_FRAMES_PER_FUNCTION,@@ -133,6 +134,7 @@ export {validateBucketName} from './validate-bucket-name';export {validateOutname} from './validate-outname';export {validatePrivacy} from './validate-privacy';export {validateWebhook} from './validate-webhook';+export {writeCancellationSignal} from './write-cancellation-signal';export * from './webhook-types';export {EnhancedErrorInfo, FunctionErrorInfo} from './write-error-to-storage';export {interpolate, random};diff --git a/packages/serverless-client/src/overall-render-progress.ts b/packages/serverless-client/src/overall-render-progress.tsindex c09ff41b29..642f08dcb5 100644--- a/packages/serverless-client/src/overall-render-progress.ts+++ b/packages/serverless-client/src/overall-render-progress.ts@@ -9,6 +9,10 @@ import type {import type {FunctionErrorInfo} from './write-error-to-storage';export type OverallRenderProgress<Provider extends CloudProvider> = {+ /**+ * Whether renderers poll for a cancellation signal.+ */+ cancellationEnabled: boolean | null;chunks: number[];framesRendered: number;framesEncoded: number;diff --git a/packages/serverless-client/src/test/progress.test.ts b/packages/serverless-client/src/test/progress.test.tsindex 643df5380d..e8c06da885 100644--- a/packages/serverless-client/src/test/progress.test.ts+++ b/packages/serverless-client/src/test/progress.test.ts@@ -66,6 +66,7 @@ const renderMetadata: RenderMetadata<MockProvider> = {};const progress: OverallRenderProgress<MockProvider> = {+ cancellationEnabled: false,chunks: [0, 1],combinedFrames: 20,compositionValidated: startedDate + 2,diff --git a/packages/serverless-client/src/write-cancellation-signal.ts b/packages/serverless-client/src/write-cancellation-signal.tsnew file mode 100644index 0000000000..2c121106b4--- /dev/null+++ b/packages/serverless-client/src/write-cancellation-signal.ts@@ -0,0 +1,35 @@+import {cancellationKey} from './constants';+import type {ProviderSpecifics} from './provider-implementation';+import type {CloudProvider} from './types';++export const writeCancellationSignal = async <Provider extends CloudProvider>({+ bucketName,+ renderId,+ region,+ expectedBucketOwner,+ providerSpecifics,+ forcePathStyle,+ requestHandler,+}: {+ bucketName: string;+ renderId: string;+ region: Provider['region'];+ expectedBucketOwner: string;+ providerSpecifics: ProviderSpecifics<Provider>;+ forcePathStyle: boolean;+ requestHandler: Provider['requestHandler'] | null;+}) => {+ await providerSpecifics.writeFile({+ bucketName,+ key: cancellationKey(renderId),+ body: JSON.stringify({cancelledAt: Date.now()}),+ region,+ privacy: 'private',+ expectedBucketOwner,+ downloadBehavior: null,+ customCredentials: null,+ forcePathStyle,+ storageClass: null,+ requestHandler,+ });+};diff --git a/packages/serverless/src/cancellation-polling.ts b/packages/serverless/src/cancellation-polling.tsnew file mode 100644index 0000000000..1fcf81a4ee--- /dev/null+++ b/packages/serverless/src/cancellation-polling.ts@@ -0,0 +1,88 @@+import {RenderInternals, type LogLevel} from '@remotion/renderer';+import type {+ CloudProvider,+ ProviderSpecifics,+} from '@remotion/serverless-client';+import {cancellationKey} from '@remotion/serverless-client';++const isMissingCancellationSignalError = (err: unknown) => {+ const error = err as {name?: string; Code?: string; code?: string};+ return (+ error.name === 'NoSuchKey' ||+ error.name === 'NotFound' ||+ error.Code === 'NoSuchKey' ||+ error.code === 'NoSuchKey'+ );+};++export const startCancellationPolling = <Provider extends CloudProvider>({+ bucketName,+ renderId,+ region,+ providerSpecifics,+ forcePathStyle,+ intervalInMilliseconds,+ logLevel,+ onCancelled,+}: {+ bucketName: string;+ renderId: string;+ region: Provider['region'];+ providerSpecifics: ProviderSpecifics<Provider>;+ forcePathStyle: boolean;+ intervalInMilliseconds: number;+ logLevel: LogLevel;+ onCancelled: () => void;+}) => {+ let stopped = false;+ let timeout: ReturnType<typeof setTimeout> | null = null;++ const poll = async () => {+ try {+ await providerSpecifics.headFile({+ bucketName,+ key: cancellationKey(renderId),+ region,+ customCredentials: null,+ forcePathStyle,+ requestHandler: null,+ });++ if (!stopped) {+ stopped = true;+ RenderInternals.Log.info(+ {indent: false, logLevel},+ 'Render cancellation signal received.',+ );+ onCancelled();+ }+ } catch (err) {+ if (!isMissingCancellationSignalError(err)) {+ RenderInternals.Log.warn(+ {indent: false, logLevel},+ 'Could not check for a render cancellation signal. Retrying.',+ err,+ );+ }+ }++ if (!stopped) {+ timeout = setTimeout(poll, intervalInMilliseconds);+ }+ };++ poll().catch((err) => {+ RenderInternals.Log.warn(+ {indent: false, logLevel},+ 'Cancellation polling stopped unexpectedly.',+ err,+ );+ });++ return () => {+ stopped = true;+ if (timeout !== null) {+ clearTimeout(timeout);+ }+ };+};diff --git a/packages/serverless/src/handlers/launch.ts b/packages/serverless/src/handlers/launch.tsindex 0aa5ffc86e..16df9fec90 100644--- a/packages/serverless/src/handlers/launch.ts+++ b/packages/serverless/src/handlers/launch.ts@@ -27,6 +27,7 @@ import {validateFramesPerFunction,validateOutname,validatePrivacy,+ writeCancellationSignal,} from '@remotion/serverless-client';import {cleanupProps} from '../cleanup-props';import {findOutputFileInBucket} from '../find-output-file-in-bucket';@@ -264,6 +265,7 @@ const innerLaunchHandler = async <Provider extends CloudProvider>({const lambdaPayloads = chunks.map((chunkPayload) => {const payload: ServerlessPayload<Provider> = {+ enableCancellation: params.enableCancellation ?? false,type: ServerlessRoutines.renderer,frameRange: chunkPayload,serveUrl: params.serveUrl,@@ -633,6 +635,30 @@ export const launchHandler = async <Provider extends CloudProvider>({return prom;};+ const cancelOtherRenderers = async () => {+ if (!params.enableCancellation) {+ return;+ }++ try {+ await writeCancellationSignal({+ bucketName: params.bucketName,+ renderId: params.renderId,+ region: insideFunctionSpecifics.getCurrentRegionInFunction(),+ expectedBucketOwner: options.expectedBucketOwner,+ providerSpecifics,+ forcePathStyle: params.forcePathStyle,+ requestHandler: null,+ });+ } catch (err) {+ RenderInternals.Log.warn(+ {indent: false, logLevel: params.logLevel},+ 'Could not signal other renderers to stop.',+ err,+ );+ }+ };+const onTimeout = async () => {RenderInternals.Log.error({indent: false, logLevel: params.logLevel},@@ -648,6 +674,7 @@ export const launchHandler = async <Provider extends CloudProvider>({}runCleanupTasks();+ await cancelOtherRenderers();if (!params.webhook) {RenderInternals.Log.verbose(@@ -741,6 +768,7 @@ export const launchHandler = async <Provider extends CloudProvider>({);const overallProgress = makeOverallRenderProgress({+ cancellationEnabled: params.enableCancellation ?? false,renderId: params.renderId,bucketName: params.bucketName,expectedBucketOwner: options.expectedBucketOwner,@@ -833,6 +861,8 @@ export const launchHandler = async <Provider extends CloudProvider>({throw err;}+ await cancelOtherRenderers();+RenderInternals.Log.error({indent: false, logLevel: params.logLevel},'Error occurred',diff --git a/packages/serverless/src/handlers/renderer.ts b/packages/serverless/src/handlers/renderer.tsindex 49acca32d0..00e801e83c 100644--- a/packages/serverless/src/handlers/renderer.ts+++ b/packages/serverless/src/handlers/renderer.ts@@ -3,10 +3,11 @@ import path from 'node:path';import type {AudioCodec,BrowserLog,+ CancelSignal,Codec,OnArtifact,} from '@remotion/renderer';-import {RenderInternals} from '@remotion/renderer';+import {makeCancelSignal, RenderInternals} from '@remotion/renderer';import {NoReactAPIs} from '@remotion/renderer/pure';import type {CloudProvider,@@ -23,6 +24,7 @@ import {truthy,VERSION,} from '@remotion/serverless-client';+import {startCancellationPolling} from '../cancellation-polling';import type {LaunchedBrowser} from '../get-browser-instance';import {getTmpDirStateIfENoSp} from '../get-tmp-dir';import {startLeakDetection} from '../leak-detection';@@ -50,6 +52,7 @@ const renderHandler = async <Provider extends CloudProvider>({insideFunctionSpecifics,onBrowserInstance,onMediaFiles,+ cancelSignal,}: {params: ServerlessPayload<Provider>;options: Options;@@ -66,6 +69,7 @@ const renderHandler = async <Provider extends CloudProvider>({completedAt: number;}) => Promise<void>)| null;+ cancelSignal: CancelSignal | null;}): Promise<{}> => {if (params.type !== ServerlessRoutines.renderer) {throw new Error('Params must be renderer');@@ -341,7 +345,7 @@ const renderHandler = async <Provider extends CloudProvider>({audioCodec,preferLossless: params.preferLossless,browserExecutable: providerSpecifics.getChromiumPath(),- cancelSignal: undefined,+ cancelSignal: cancelSignal ?? undefined,disallowParallelEncoding: false,ffmpegOverride: ({args}) => args,indent: false,@@ -491,6 +495,23 @@ export const rendererHandler = async <Provider extends CloudProvider>({const leakDetection = enableNodeIntrospection(ENABLE_SLOW_LEAK_DETECTION);let shouldKeepBrowserOpen = true;let instance: LaunchedBrowser | undefined;+ let cancellationRequested = false;+ const {cancel, cancelSignal} = makeCancelSignal();+ const stopCancellationPolling = params.enableCancellation+ ? startCancellationPolling({+ bucketName: params.bucketName,+ renderId: params.renderId,+ region: insideFunctionSpecifics.getCurrentRegionInFunction(),+ providerSpecifics,+ forcePathStyle: params.forcePathStyle,+ intervalInMilliseconds: 1000,+ logLevel: params.logLevel,+ onCancelled: () => {+ cancellationRequested = true;+ cancel();+ },+ })+ : () => undefined;try {await renderHandler({@@ -504,6 +525,7 @@ export const rendererHandler = async <Provider extends CloudProvider>({instance = browserInstance;},onMediaFiles,+ cancelSignal: params.enableCancellation ? cancelSignal : null,});} catch (err) {if (process.env.NODE_ENV === 'test') {@@ -519,7 +541,8 @@ export const rendererHandler = async <Provider extends CloudProvider>({shouldKeepBrowserOpen = false;}- const shouldNotRetry = (err as Error).name === 'CancelledError';+ const shouldNotRetry =+ cancellationRequested || (err as Error).name === 'CancelledError';const shouldRetry =isRetryableError && params.retriesLeft > 0 && !shouldNotRetry;@@ -557,6 +580,7 @@ export const rendererHandler = async <Provider extends CloudProvider>({},});} finally {+ stopCancellationPolling();if (shouldKeepBrowserOpen && instance) {insideFunctionSpecifics.forgetBrowserEventLoop({logLevel: params.logLevel,diff --git a/packages/serverless/src/handlers/start.ts b/packages/serverless/src/handlers/start.tsindex d638d6790c..3ac7e3b3e0 100644--- a/packages/serverless/src/handlers/start.ts+++ b/packages/serverless/src/handlers/start.ts@@ -69,6 +69,7 @@ export const startHandler = async <Provider extends CloudProvider>({body: JSON.stringify(makeInitialOverallRenderProgress(options.timeoutInMilliseconds + Date.now(),+ params.enableCancellation ?? false,),),expectedBucketOwner: options.expectedBucketOwner,@@ -81,6 +82,7 @@ export const startHandler = async <Provider extends CloudProvider>({});const payload: ServerlessPayload<Provider> = {+ enableCancellation: params.enableCancellation ?? false,type: ServerlessRoutines.launch,framesPerFunction: params.framesPerLambda,concurrency: params.concurrency,diff --git a/packages/serverless/src/handlers/still.ts b/packages/serverless/src/handlers/still.tsindex a25381d11f..1467dac26b 100644--- a/packages/serverless/src/handlers/still.ts+++ b/packages/serverless/src/handlers/still.ts@@ -218,7 +218,7 @@ const innerStillHandler = async <Provider extends CloudProvider>(scale: params.scale,};- const still = makeInitialOverallRenderProgress(timeoutInMilliseconds);+ const still = makeInitialOverallRenderProgress(timeoutInMilliseconds, false);still.renderMetadata = renderMetadata;await providerSpecifics.writeFile({diff --git a/packages/serverless/src/overall-render-progress.ts b/packages/serverless/src/overall-render-progress.tsindex 3d331c4293..4e591c032e 100644--- a/packages/serverless/src/overall-render-progress.ts+++ b/packages/serverless/src/overall-render-progress.ts@@ -56,8 +56,10 @@ export const makeInitialOverallRenderProgress = <Provider extends CloudProvider,>(timeoutTimestamp: number,+ cancellationEnabled: boolean,): OverallRenderProgress<Provider> => {return {+ cancellationEnabled,chunks: [],framesRendered: 0,framesEncoded: 0,@@ -89,6 +91,7 @@ export const makeOverallRenderProgress = <Provider extends CloudProvider>({logLevel,providerSpecifics,forcePathStyle,+ cancellationEnabled,}: {renderId: string;bucketName: string;@@ -98,13 +101,14 @@ export const makeOverallRenderProgress = <Provider extends CloudProvider>({logLevel: LogLevel;providerSpecifics: ProviderSpecifics<Provider>;forcePathStyle: boolean;+ cancellationEnabled: boolean;}): OverallProgressHelper<Provider> => {let framesRendered: number[] = [];let framesEncoded: number[] = [];let lambdasInvoked: boolean[] = [];const renderProgress: OverallRenderProgress<Provider> =- makeInitialOverallRenderProgress(timeoutTimestamp);+ makeInitialOverallRenderProgress(timeoutTimestamp, cancellationEnabled);let dirty = false;let dirtyReasons: string[] = [];diff --git a/packages/serverless/src/test/cancellation-polling.test.ts b/packages/serverless/src/test/cancellation-polling.test.tsnew file mode 100644index 0000000000..59d80f695e--- /dev/null+++ b/packages/serverless/src/test/cancellation-polling.test.ts@@ -0,0 +1,48 @@+import {expect, test} from 'bun:test';+import type {+ CloudProvider,+ ProviderSpecifics,+} from '@remotion/serverless-client';+import {cancellationKey} from '@remotion/serverless-client';+import {startCancellationPolling} from '../cancellation-polling';++type MockProvider = CloudProvider<+ 'eu-central-1',+ {s3Key: string; s3Url: string},+ {},+ 'standard',+ {}+>;++test('polls until the cancellation signal exists', async () => {+ let checks = 0;+ let stop: () => void = () => undefined;+ const cancelled = new Promise<void>((resolve) => {+ stop = startCancellationPolling({+ bucketName: 'bucket',+ renderId: 'render-id',+ region: 'eu-central-1',+ providerSpecifics: {+ headFile: (({key}) => {+ expect(key).toBe(cancellationKey('render-id'));+ checks++;+ if (checks === 1) {+ const error = new Error('Missing');+ error.name = 'NotFound';+ return Promise.reject(error);+ }++ return Promise.resolve({});+ }) as ProviderSpecifics<MockProvider>['headFile'],+ } as unknown as ProviderSpecifics<MockProvider>,+ forcePathStyle: false,+ intervalInMilliseconds: 1,+ logLevel: 'error',+ onCancelled: resolve,+ });+ });++ await cancelled;+ stop();+ expect(checks).toBe(2);+});diff --git a/packages/serverless/src/test/overall-render-progress.test.ts b/packages/serverless/src/test/overall-render-progress.test.tsindex bf07e403c6..5db6424958 100644--- a/packages/serverless/src/test/overall-render-progress.test.ts+++ b/packages/serverless/src/test/overall-render-progress.test.ts@@ -4,7 +4,10 @@ import type {PostRenderData,ProviderSpecifics,} from '@remotion/serverless-client';-import {makeOverallRenderProgress} from '../overall-render-progress';+import {+ makeInitialOverallRenderProgress,+ makeOverallRenderProgress,+} from '../overall-render-progress';type MockProvider = CloudProvider<'eu-central-1',@@ -85,6 +88,11 @@ const postRenderData: PostRenderData<MockProvider> = {timeToRenderFrames: 1,};+test('stores whether cancellation is enabled', () => {+ const progress = makeInitialOverallRenderProgress<MockProvider>(1, true);+ expect(progress.cancellationEnabled).toBe(true);+});+test('setPostRenderData retries transient progress upload failures', async () => {let attempts = 0;let persistedBody: string | null = null;@@ -100,6 +108,7 @@ test('setPostRenderData retries transient progress upload failures', async () =>},});const overallProgress = makeOverallRenderProgress({+ cancellationEnabled: false,bucketName: 'bucket',expectedBucketOwner: '123456789012',forcePathStyle: false,diff --git a/packages/studio-shared/src/config-method-lifecycles.ts b/packages/studio-shared/src/config-method-lifecycles.tsindex d26c77eef6..40f74173c6 100644--- a/packages/studio-shared/src/config-method-lifecycles.ts+++ b/packages/studio-shared/src/config-method-lifecycles.ts@@ -40,6 +40,7 @@ export const configMethodLifecycles = {setDeleteAfter: 'runtime',setDisallowParallelEncoding: 'runtime',setDotEnvLocation: 'restart',+ setEnableCancellation: 'runtime',setEnableCrossSiteIsolation: 'restart',setEnableFolderExpiry: 'runtime',setEncodingBufferSize: 'runtime',