@remotion/lambda 4.0.254 → 4.0.256

package/dist/shared/cleanup-serialized-input-props.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupSerializedResolvedProps = exports.cleanupSerializedInputProps = void 0;
+const client_1 = require("@remotion/serverless/client");
+const cleanupSerializedInputProps = async ({ serialized, region, providerSpecifics, forcePathStyle, }) => {
+    if (serialized.type === 'payload') {
+        return 0;
+    }
+    const time = Date.now();
+    await providerSpecifics.deleteFile({
+        bucketName: serialized.bucketName,
+        key: (0, client_1.inputPropsKey)(serialized.hash),
+        region,
+        customCredentials: null,
+        forcePathStyle,
+    });
+    return Date.now() - time;
+};
+exports.cleanupSerializedInputProps = cleanupSerializedInputProps;
+const cleanupSerializedResolvedProps = async ({ serialized, region, providerSpecifics, forcePathStyle, }) => {
+    if (serialized.type === 'payload') {
+        return 0;
+    }
+    const time = Date.now();
+    await providerSpecifics.deleteFile({
+        bucketName: serialized.bucketName,
+        key: (0, client_1.resolvedPropsKey)(serialized.hash),
+        region,
+        customCredentials: null,
+        forcePathStyle,
+    });
+    return Date.now() - time;
+};
+exports.cleanupSerializedResolvedProps = cleanupSerializedResolvedProps;

package/dist/shared/docs-url.d.ts

@@ -0,0 +1 @@
+export declare const DOCS_URL = "https://remotion.dev";

package/dist/shared/docs-url.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOCS_URL = void 0;
+exports.DOCS_URL = 'https://remotion.dev';

package/dist/shared/get-most-expensive-chunks.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedTiming } from './parse-lambda-timings-key';
+export declare const OVERHEAD_TIME_PER_LAMBDA = 100;
+export type ExpensiveChunk = {
+    chunk: number;
+    frameRange: [number, number];
+    timeInMilliseconds: number;
+};
+export declare const getMostExpensiveChunks: (parsedTimings: ParsedTiming[], framesPerLambda: number, firstFrame: number, lastFrame: number) => ExpensiveChunk[];

package/dist/shared/get-most-expensive-chunks.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMostExpensiveChunks = exports.OVERHEAD_TIME_PER_LAMBDA = void 0;
+exports.OVERHEAD_TIME_PER_LAMBDA = 100;
+const getMostExpensiveChunks = (parsedTimings, framesPerLambda, firstFrame, lastFrame) => {
+    const mostExpensiveChunks = parsedTimings
+        .slice(0)
+        .sort((a, b) => {
+        const durA = a.rendered - a.start;
+        const durB = b.rendered - b.start;
+        return durB - durA;
+    })
+        .slice(0, 5);
+    return mostExpensiveChunks.map((c) => {
+        const isLastChunk = c.chunk === parsedTimings.length - 1;
+        return {
+            timeInMilliseconds: c.rendered - c.start,
+            chunk: c.chunk,
+            frameRange: [
+                framesPerLambda * c.chunk + firstFrame,
+                isLastChunk
+                    ? lastFrame
+                    : framesPerLambda * (c.chunk + 1) - 1 + firstFrame,
+            ],
+        };
+    });
+};
+exports.getMostExpensiveChunks = getMostExpensiveChunks;

package/dist/shared/invoke-webhook.d.ts

@@ -0,0 +1,48 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { EnhancedErrorInfo } from '@remotion/serverless';
+import https from 'https';
+import http from 'node:http';
+import type { AfterRenderCost } from './constants';
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+export declare function calculateSignature(payload: string, secret: string | null): string;
+type DynamicWebhookPayload = {
+    type: 'error';
+    errors: {
+        message: string;
+        name: string;
+        stack: string;
+    }[];
+} | {
+    type: 'success';
+    lambdaErrors: EnhancedErrorInfo[];
+    outputUrl: string | undefined;
+    outputFile: string | undefined;
+    timeToFinish: number | undefined;
+    costs: AfterRenderCost;
+} | {
+    type: 'timeout';
+};
+export type WebhookPayload = {
+    renderId: string;
+    expectedBucketOwner: string;
+    bucketName: string;
+    customData: Record<string, unknown> | null;
+} & DynamicWebhookPayload;
+export declare const mockableHttpClients: {
+    http: typeof http.request;
+    https: typeof https.request;
+};
+type InvokeWebhookOptions = {
+    payload: WebhookPayload;
+    url: string;
+    secret: string | null;
+    redirectsSoFar: number;
+};
+export declare const invokeWebhook: (options: InvokeWebhookOptions, logLevel: LogLevel, retries?: number, errors?: number) => Promise<void>;
+export {};

package/dist/shared/invoke-webhook.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeWebhook = exports.mockableHttpClients = void 0;
+exports.calculateSignature = calculateSignature;
+const renderer_1 = require("@remotion/renderer");
+const https_1 = __importDefault(require("https"));
+const Crypto = __importStar(require("node:crypto"));
+const node_http_1 = __importDefault(require("node:http"));
+/**
+ * @description Calculates cryptographically secure signature for webhooks using Hmac.
+ * @link https://remotion.dev/docs/lambda/webhooks#validate-webhooks
+ * @param payload Stringified request body to encode in the signature.
+ * @param secret User-provided webhook secret used to sign the request.
+ * @returns {string} Calculated signature
+ */
+function calculateSignature(payload, secret) {
+    if (!secret) {
+        return 'NO_SECRET_PROVIDED';
+    }
+    const hmac = Crypto.createHmac('sha512', secret);
+    const signature = 'sha512=' + hmac.update(payload).digest('hex');
+    return signature;
+}
+exports.mockableHttpClients = {
+    http: node_http_1.default.request,
+    https: https_1.default.request,
+};
+// Don't handle 304 status code (Not Modified) as a redirect,
+// since the browser will display the right page.
+const redirectStatusCodes = [301, 302, 303, 307, 308];
+const getWebhookClient = (url) => {
+    if (url.startsWith('https://')) {
+        return exports.mockableHttpClients.https;
+    }
+    if (url.startsWith('http://')) {
+        return exports.mockableHttpClients.http;
+    }
+    throw new Error('Can only request URLs starting with http:// or https://');
+};
+function invokeWebhookRaw({ payload, secret, url, redirectsSoFar, }) {
+    const jsonPayload = JSON.stringify(payload);
+    return new Promise((resolve, reject) => {
+        const req = getWebhookClient(url)(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': jsonPayload.length,
+                'X-Remotion-Mode': 'production',
+                'X-Remotion-Signature': calculateSignature(jsonPayload, secret),
+                'X-Remotion-Status': payload.type,
+            },
+            timeout: 5000,
+        }, (res) => {
+            if (res.statusCode && res.statusCode > 299) {
+                if (redirectStatusCodes.includes(res.statusCode)) {
+                    if (!res.headers.location) {
+                        reject(new Error(`Received a status code ${res.statusCode} but no "Location" header while calling ${res.headers.location}`));
+                        return;
+                    }
+                    if (redirectsSoFar > 10) {
+                        reject(new Error(`Too many redirects while downloading ${url}`));
+                        return;
+                    }
+                    invokeWebhookRaw({
+                        payload,
+                        secret,
+                        url: res.headers.location,
+                        redirectsSoFar: redirectsSoFar + 1,
+                    })
+                        .then(resolve)
+                        .catch(reject);
+                    return;
+                }
+                reject(new Error(`Sent a webhook to ${url} but got a status code of ${res.statusCode} with message '${res.statusMessage}'`));
+                return;
+            }
+            resolve();
+        });
+        req.write(jsonPayload, (err) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                req.end();
+            }
+        });
+        req.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+function exponentialBackoff(errorCount) {
+    return 1000 * 2 ** (errorCount - 1);
+}
+const invokeWebhook = async (options, logLevel, retries = 2, errors = 0) => {
+    try {
+        await invokeWebhookRaw(options);
+    }
+    catch (err) {
+        if (retries === 0) {
+            throw err;
+        }
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, 'Could not send webhook due to error:');
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, err.stack);
+        renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, `Retrying in ${exponentialBackoff(errors)}ms.`);
+        await new Promise((resolve) => {
+            setTimeout(() => {
+                resolve();
+            }, exponentialBackoff(errors));
+        });
+        return (0, exports.invokeWebhook)(options, logLevel, retries - 1, errors + 1);
+    }
+};
+exports.invokeWebhook = invokeWebhook;

package/dist/shared/parse-lambda-timings-key.d.ts

@@ -0,0 +1,5 @@
+export type ParsedTiming = {
+    chunk: number;
+    start: number;
+    rendered: number;
+};

package/dist/shared/parse-lambda-timings-key.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/return-values.d.ts

@@ -0,0 +1,16 @@
+import type { CloudProvider, compositionsHandler, infoHandler } from '@remotion/serverless';
+import type { ServerlessRoutines } from '@remotion/serverless/client';
+import type { launchHandler } from '../functions/launch';
+import type { progressHandler } from '../functions/progress';
+import type { rendererHandler } from '../functions/renderer';
+import type { startHandler } from '../functions/start';
+import type { stillHandler } from '../functions/still';
+export interface LambdaReturnValues<Provider extends CloudProvider> {
+    [ServerlessRoutines.start]: ReturnType<typeof startHandler>;
+    [ServerlessRoutines.launch]: ReturnType<typeof launchHandler>;
+    [ServerlessRoutines.renderer]: ReturnType<typeof rendererHandler>;
+    [ServerlessRoutines.status]: ReturnType<typeof progressHandler<Provider>>;
+    [ServerlessRoutines.info]: ReturnType<typeof infoHandler<Provider>>;
+    [ServerlessRoutines.still]: ReturnType<typeof stillHandler>;
+    [ServerlessRoutines.compositions]: ReturnType<typeof compositionsHandler>;
+}

package/dist/shared/return-values.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/stackback.d.ts

@@ -0,0 +1,6 @@
+export declare const stackback: (error: Error) => NodeJS.CallSite[];
+declare global {
+    interface Error {
+        _sb_callsites: NodeJS.CallSite[];
+    }
+}

package/dist/shared/stackback.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stackback = void 0;
+function FormatStackTrace(error, frames) {
+    const lines = [];
+    try {
+        lines.push(error.toString());
+    }
+    catch (e) {
+        try {
+            lines.push('<error: ' + e + '>');
+        }
+        catch (_a) {
+            lines.push('<error>');
+        }
+    }
+    for (let i = 0; i < frames.length; i++) {
+        const frame = frames[i];
+        let line;
+        try {
+            line = frame.toString();
+        }
+        catch (e) {
+            try {
+                line = '<error: ' + e + '>';
+            }
+            catch (_b) {
+                // Any code that reaches this point is seriously nasty!
+                line = '<error>';
+            }
+        }
+        lines.push('    at ' + line);
+    }
+    return lines.join('\n');
+}
+const stackback = (error) => {
+    // save original stacktrace
+    const save = Error.prepareStackTrace;
+    // replace capture with our function
+    Error.prepareStackTrace = function (err, trace) {
+        // cache stack frames so we don't have to get them again
+        // use a non-enumerable property
+        Object.defineProperty(err, '_sb_callsites', {
+            value: trace,
+        });
+        return (save || FormatStackTrace)(err, trace);
+    };
+    // force capture of the stack frames
+    // eslint-disable-next-line no-unused-expressions
+    error.stack;
+    // someone already asked for the stack so we can't do this trick
+    if (!error._sb_callsites) {
+        return [];
+    }
+    // return original capture function
+    Error.prepareStackTrace = save;
+    return error._sb_callsites;
+};
+exports.stackback = stackback;

package/dist/shared/validate-download-behavior.d.ts

@@ -0,0 +1 @@
+export declare const validateDownloadBehavior: (downloadBehavior: unknown) => null | undefined;

package/dist/shared/validate-download-behavior.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDownloadBehavior = void 0;
+const validateDownloadBehavior = (downloadBehavior) => {
+    if (downloadBehavior === null || downloadBehavior === undefined) {
+        return null;
+    }
+    if (typeof downloadBehavior !== 'object') {
+        throw new Error('downloadBehavior must be null or an object');
+    }
+    const behavior = downloadBehavior;
+    if (behavior.type !== 'download' && behavior.type !== 'play-in-browser') {
+        throw new Error('Download behavior must be either "download" or "play-in-browser"');
+    }
+    if (behavior.type === 'download') {
+        if (typeof behavior.fileName !== 'string' && behavior.fileName !== null) {
+            throw new Error('If "downloadBehavior.type" is "download", then fileName must be "null" or a string');
+        }
+    }
+};
+exports.validateDownloadBehavior = validateDownloadBehavior;

package/dist/shared/validate-frames-per-lambda.d.ts

@@ -0,0 +1,4 @@
+export declare const validateFramesPerLambda: ({ framesPerLambda, durationInFrames, }: {
+    framesPerLambda: unknown;
+    durationInFrames: number;
+}) => void;

package/dist/shared/validate-frames-per-lambda.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFramesPerLambda = void 0;
+const constants_1 = require("./constants");
+const validateFramesPerLambda = ({ framesPerLambda, durationInFrames, }) => {
+    if (framesPerLambda === null) {
+        return;
+    }
+    if (framesPerLambda === undefined) {
+        return;
+    }
+    if (typeof framesPerLambda !== 'number') {
+        throw new TypeError(`'framesPerLambda' needs to be a number, passed ${JSON.stringify(framesPerLambda)}`);
+    }
+    if (!Number.isFinite(framesPerLambda)) {
+        throw new TypeError(`'framesPerLambda' needs to be finite, passed ${framesPerLambda}`);
+    }
+    if (Number.isNaN(framesPerLambda)) {
+        throw new TypeError(`'framesPerLambda' needs to be NaN, passed ${framesPerLambda}`);
+    }
+    if (framesPerLambda % 1 !== 0) {
+        throw new TypeError(`'framesPerLambda' needs to be an integer, passed ${framesPerLambda}`);
+    }
+    const effectiveMinimum = Math.min(constants_1.MINIMUM_FRAMES_PER_LAMBDA, durationInFrames);
+    if (framesPerLambda < effectiveMinimum) {
+        throw new TypeError(`The framesPerLambda needs to be at least ${effectiveMinimum}, but is ${framesPerLambda}`);
+    }
+};
+exports.validateFramesPerLambda = validateFramesPerLambda;

package/dist/shared/validate-privacy.d.ts

@@ -0,0 +1,2 @@
+import type { Privacy } from '@remotion/serverless/client';
+export declare function validatePrivacy(privacy: unknown, allowPrivate: boolean): asserts privacy is Privacy;

package/dist/shared/validate-privacy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePrivacy = validatePrivacy;
+function validatePrivacy(privacy, allowPrivate) {
+    if (typeof privacy !== 'string') {
+        throw new TypeError('Privacy must be a string');
+    }
+    if (!allowPrivate && privacy === 'private') {
+        throw new TypeError('Privacy must be either "public" or "no-acl"');
+    }
+    if (privacy !== 'private' && privacy !== 'public' && privacy !== 'no-acl') {
+        throw new TypeError('Privacy must be either "private", "public" or "no-acl"');
+    }
+}

package/dist/shared/validate.d.ts

@@ -0,0 +1,4 @@
+import { NoReactInternals } from 'remotion/no-react';
+export declare const validateFps: typeof NoReactInternals.validateFps;
+export declare const validateDimension: typeof NoReactInternals.validateDimension;
+export declare const validateDurationInFrames: typeof NoReactInternals.validateDurationInFrames;

package/dist/shared/validate.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDurationInFrames = exports.validateDimension = exports.validateFps = void 0;
+/* eslint-disable prefer-destructuring */
+const no_react_1 = require("remotion/no-react");
+exports.validateFps = no_react_1.NoReactInternals.validateFps;
+exports.validateDimension = no_react_1.NoReactInternals.validateDimension;
+exports.validateDurationInFrames = no_react_1.NoReactInternals.validateDurationInFrames;

package/dist/shared/why-is-node-running.d.ts

@@ -0,0 +1,15 @@
+import asyncHooks from 'async_hooks';
+type Resource = {
+    type: string;
+    stacks: NodeJS.CallSite[];
+    resource: {
+        hasRef?: () => boolean;
+    };
+};
+export type NodeIntrospection = {
+    hook: asyncHooks.AsyncHook | null;
+    active: Map<number, Resource>;
+};
+export declare const enableNodeIntrospection: (enabled: boolean) => NodeIntrospection;
+export declare function whyIsNodeRunning({ active, hook }: NodeIntrospection): void;
+export {};

package/dist/shared/why-is-node-running.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableNodeIntrospection = void 0;
+exports.whyIsNodeRunning = whyIsNodeRunning;
+const async_hooks_1 = __importDefault(require("async_hooks"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const stackback_1 = require("./stackback");
+const enableNodeIntrospection = (enabled) => {
+    const active = new Map();
+    if (!enabled) {
+        return {
+            active,
+            hook: null,
+        };
+    }
+    const hook = async_hooks_1.default.createHook({
+        init(asyncId, type, _triggerAsyncId, resource) {
+            if (type === 'TIMERWRAP' || type === 'PROMISE')
+                return;
+            if (type === 'PerformanceObserver' || type === 'RANDOMBYTESREQUEST')
+                return;
+            const err = new Error('whatevs');
+            const stacks = (0, stackback_1.stackback)(err);
+            active.set(asyncId, { type, stacks, resource });
+        },
+        destroy(asyncId) {
+            active.delete(asyncId);
+        },
+    });
+    hook.enable();
+    return { hook, active };
+};
+exports.enableNodeIntrospection = enableNodeIntrospection;
+function whyIsNodeRunning({ active, hook }) {
+    if (!hook) {
+        return;
+    }
+    hook.disable();
+    const activeResources = [...active.values()].filter((r) => {
+        if (typeof r.resource.hasRef === 'function' && !r.resource.hasRef())
+            return false;
+        return true;
+    });
+    console.error('There are %d handle(s) keeping the process running', activeResources.length);
+    function printStacks(o) {
+        const stacks = o.stacks.slice(1).filter((s) => {
+            const filename = s.getFileName();
+            return (filename &&
+                filename.indexOf(path_1.sep) > -1 &&
+                filename.indexOf('internal' + path_1.sep) !== 0);
+        });
+        console.error('');
+        console.error('# %s', o.type);
+        if (stacks[0]) {
+            let padding = '';
+            stacks.forEach((s) => {
+                const pad = (s.getFileName() + ':' + s.getLineNumber()).replace(/./g, ' ');
+                if (pad.length > padding.length)
+                    padding = pad;
+            });
+            stacks.forEach((s) => {
+                const prefix = s.getFileName() + ':' + s.getLineNumber();
+                try {
+                    const src = fs_1.default
+                        .readFileSync(s.getFileName(), 'utf-8')
+                        .split(/\n|\r\n/);
+                    console.error(prefix +
+                        padding.slice(prefix.length) +
+                        ' - ' +
+                        src[s.getLineNumber() - 1].trim());
+                }
+                catch (_a) {
+                    console.error(prefix + padding.slice(prefix.length));
+                }
+            });
+        }
+        else {
+            console.error('(unknown stack trace)');
+        }
+    }
+    for (const o of activeResources) {
+        printStacks(o);
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/lambda"
   },
   "name": "@remotion/lambda",
-  "version": "4.0.254",
+  "version": "4.0.256",
   "description": "Render Remotion videos on AWS Lambda",
   "main": "dist/index.js",
   "sideEffects": false,
@@ -22,13 +22,13 @@
     "@smithy/abort-controller": "3.1.1",
     "mime-types": "2.1.34",
     "zod": "3.22.3",
-    "@remotion/serverless": "4.0.254",
-    "@remotion/bundler": "4.0.254",
-    "@remotion/renderer": "4.0.254",
-    "@remotion/cli": "4.0.254",
-    "@remotion/studio-server": "4.0.254",
-    "@remotion/streaming": "4.0.254",
-    "remotion": "4.0.254"
+    "@remotion/bundler": "4.0.256",
+    "@remotion/serverless": "4.0.256",
+    "@remotion/cli": "4.0.256",
+    "remotion": "4.0.256",
+    "@remotion/studio-server": "4.0.256",
+    "@remotion/renderer": "4.0.256",
+    "@remotion/streaming": "4.0.256"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
@@ -40,12 +40,12 @@
     "next": "15.1.2",
     "pureimage": "0.4.13",
     "zip-lib": "^0.7.2",
-    "@remotion/bundler": "4.0.254",
-    "@remotion/eslint-config-internal": "4.0.254",
-    "@remotion/compositor-linux-arm64-gnu": "4.0.254"
+    "@remotion/bundler": "4.0.256",
+    "@remotion/compositor-linux-arm64-gnu": "4.0.256",
+    "@remotion/eslint-config-internal": "4.0.256"
   },
   "peerDependencies": {
-    "@remotion/bundler": "4.0.254"
+    "@remotion/bundler": "4.0.256"
   },
   "publishConfig": {
     "access": "public"