@remotion/studio-server 4.0.470 → 4.0.471

package/dist/preview-server/routes/delete-keyframes.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteKeyframesHandler = exports.deleteKeyframes = void 0;
+const node_fs_1 = require("node:fs");
+const renderer_1 = require("@remotion/renderer");
+const studio_shared_1 = require("@remotion/studio-shared");
+const parse_ast_1 = require("../../codemods/parse-ast");
+const update_keyframes_1 = require("../../codemods/update-keyframes/update-keyframes");
+const file_watcher_1 = require("../../file-watcher");
+const resolve_file_inside_project_1 = require("../../helpers/resolve-file-inside-project");
+const undo_stack_1 = require("../undo-stack");
+const watch_ignore_next_change_1 = require("../watch-ignore-next-change");
+const can_update_effect_props_1 = require("./can-update-effect-props");
+const can_update_sequence_props_1 = require("./can-update-sequence-props");
+const log_effect_update_1 = require("./log-updates/log-effect-update");
+const log_update_1 = require("./log-updates/log-update");
+const save_props_mutex_1 = require("./save-props-mutex");
+const groupBy = (items, getKey) => {
+    var _a;
+    const groups = new Map();
+    for (const item of items) {
+        const key = getKey(item);
+        const group = (_a = groups.get(key)) !== null && _a !== void 0 ? _a : [];
+        group.push(item);
+        groups.set(key, group);
+    }
+    return [...groups.values()];
+};
+const getBatchDescription = ({ totalKeyframes, firstKeyframe, }) => {
+    if (totalKeyframes === 1) {
+        return {
+            undoMessage: `↩️  ${firstKeyframe.key} keyframe restored at frame ${firstKeyframe.frame}`,
+            redoMessage: `↪️  ${firstKeyframe.key} keyframe deleted at frame ${firstKeyframe.frame}`,
+        };
+    }
+    return {
+        undoMessage: `↩️  ${totalKeyframes} keyframes restored`,
+        redoMessage: `↪️  ${totalKeyframes} keyframes deleted`,
+    };
+};
+const deleteKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remotionRoot, logLevel, }) => {
+    var _a, _b;
+    const totalKeyframes = sequenceKeyframes.length + effectKeyframes.length;
+    if (totalKeyframes === 0) {
+        throw new Error('No keyframes were specified for deletion');
+    }
+    const fileGroups = new Map();
+    const resolvedSequenceKeyframes = [];
+    const resolvedEffectKeyframes = [];
+    for (const [index, keyframe] of sequenceKeyframes.entries()) {
+        const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName: keyframe.fileName,
+            action: 'modify',
+        });
+        const group = (_a = fileGroups.get(absolutePath)) !== null && _a !== void 0 ? _a : {
+            fileRelativeToRoot,
+            sequenceKeyframes: [],
+            effectKeyframes: [],
+        };
+        const resolved = { ...keyframe, index, absolutePath, fileRelativeToRoot };
+        group.sequenceKeyframes.push(resolved);
+        resolvedSequenceKeyframes.push(resolved);
+        fileGroups.set(absolutePath, group);
+    }
+    for (const [index, keyframe] of effectKeyframes.entries()) {
+        const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName: keyframe.fileName,
+            action: 'modify',
+        });
+        const group = (_b = fileGroups.get(absolutePath)) !== null && _b !== void 0 ? _b : {
+            fileRelativeToRoot,
+            sequenceKeyframes: [],
+            effectKeyframes: [],
+        };
+        const resolved = { ...keyframe, index, absolutePath, fileRelativeToRoot };
+        group.effectKeyframes.push(resolved);
+        resolvedEffectKeyframes.push(resolved);
+        fileGroups.set(absolutePath, group);
+    }
+    const snapshots = [];
+    const outputByPath = new Map();
+    const sequenceLogs = [];
+    const effectLogs = [];
+    for (const [absolutePath, group] of fileGroups) {
+        const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
+        let output = fileContents;
+        let firstLogLine = Number.POSITIVE_INFINITY;
+        for (const keyframeGroup of groupBy(group.sequenceKeyframes, (keyframe) => JSON.stringify(keyframe.nodePath.nodePath))) {
+            const [firstSequenceKeyframe] = keyframeGroup;
+            if (!firstSequenceKeyframe) {
+                continue;
+            }
+            const result = await (0, update_keyframes_1.updateSequenceKeyframes)({
+                input: output,
+                nodePath: firstSequenceKeyframe.nodePath.nodePath,
+                updates: keyframeGroup.map((keyframe) => ({
+                    key: keyframe.key,
+                    operation: {
+                        type: 'remove',
+                        frame: keyframe.frame,
+                    },
+                })),
+            });
+            output = result.output;
+            firstLogLine = Math.min(firstLogLine, result.logLine);
+            for (const [keyframeIndex, keyframe] of keyframeGroup.entries()) {
+                sequenceLogs.push({
+                    fileRelativeToRoot: keyframe.fileRelativeToRoot,
+                    line: result.logLine,
+                    key: keyframe.key,
+                    oldValueString: result.oldValueStrings[keyframeIndex],
+                    newValueString: result.newValueStrings[keyframeIndex],
+                    formatted: result.formatted,
+                });
+            }
+        }
+        for (const keyframeGroup of groupBy(group.effectKeyframes, (keyframe) => `${JSON.stringify(keyframe.sequenceNodePath.nodePath)}:${keyframe.effectIndex}`)) {
+            const [firstEffectKeyframe] = keyframeGroup;
+            if (!firstEffectKeyframe) {
+                continue;
+            }
+            const result = await (0, update_keyframes_1.updateEffectKeyframes)({
+                input: output,
+                sequenceNodePath: firstEffectKeyframe.sequenceNodePath.nodePath,
+                effectIndex: firstEffectKeyframe.effectIndex,
+                updates: keyframeGroup.map((keyframe) => ({
+                    key: keyframe.key,
+                    operation: {
+                        type: 'remove',
+                        frame: keyframe.frame,
+                    },
+                })),
+            });
+            output = result.output;
+            firstLogLine = Math.min(firstLogLine, result.logLine);
+            for (const [keyframeIndex, keyframe] of keyframeGroup.entries()) {
+                effectLogs.push({
+                    fileRelativeToRoot: keyframe.fileRelativeToRoot,
+                    line: result.logLine,
+                    effectName: result.effectCallee,
+                    propKey: keyframe.key,
+                    oldValueString: result.oldValueStrings[keyframeIndex],
+                    newValueString: result.newValueStrings[keyframeIndex],
+                    formatted: result.formatted,
+                });
+            }
+        }
+        snapshots.push({
+            filePath: absolutePath,
+            oldContents: fileContents,
+            newContents: output,
+            logLine: Number.isFinite(firstLogLine) ? firstLogLine : 1,
+        });
+        outputByPath.set(absolutePath, output);
+    }
+    const [firstKeyframe] = sequenceKeyframes.length > 0 ? sequenceKeyframes : effectKeyframes;
+    if (!firstKeyframe) {
+        throw new Error('No keyframes were specified for deletion');
+    }
+    (0, undo_stack_1.pushTransactionToUndoStack)({
+        snapshots,
+        logLevel,
+        remotionRoot,
+        description: getBatchDescription({ totalKeyframes, firstKeyframe }),
+        entryType: sequenceKeyframes.length > 0 && effectKeyframes.length > 0
+            ? 'keyframe-delete'
+            : sequenceKeyframes.length > 0
+                ? 'sequence-props'
+                : 'effect-props',
+        suppressHmrOnFileRestore: true,
+    });
+    for (const snapshot of snapshots) {
+        (0, undo_stack_1.suppressUndoStackInvalidation)(snapshot.filePath);
+        (0, watch_ignore_next_change_1.suppressBundlerUpdateForFile)(snapshot.filePath);
+        (0, file_watcher_1.writeFileAndNotifyFileWatchers)(snapshot.filePath, snapshot.newContents, clientId);
+    }
+    for (const log of sequenceLogs) {
+        (0, log_update_1.logUpdate)({
+            fileRelativeToRoot: log.fileRelativeToRoot,
+            line: log.line,
+            key: log.key,
+            oldValueString: log.oldValueString,
+            newValueString: log.newValueString,
+            defaultValueString: null,
+            formatted: log.formatted,
+            logLevel,
+            removedProps: [],
+            addedProps: [],
+        });
+    }
+    for (const log of effectLogs) {
+        (0, log_effect_update_1.logEffectUpdate)({
+            fileRelativeToRoot: log.fileRelativeToRoot,
+            line: log.line,
+            effectName: log.effectName,
+            propKey: log.propKey,
+            oldValueString: log.oldValueString,
+            newValueString: log.newValueString,
+            defaultValueString: null,
+            formatted: log.formatted,
+            logLevel,
+            removedProps: [],
+            addedProps: [],
+        });
+    }
+    (0, undo_stack_1.printUndoHint)(logLevel);
+    const sequenceResults = resolvedSequenceKeyframes.map((keyframe) => {
+        const output = outputByPath.get(keyframe.absolutePath);
+        if (!output) {
+            throw new Error('Could not compute sequence keyframe deletion status');
+        }
+        const status = (0, can_update_sequence_props_1.computeSequencePropsStatusFromContent)({
+            fileContents: output,
+            keys: (0, studio_shared_1.getAllSchemaKeys)(keyframe.schema),
+            nodePath: keyframe.nodePath.nodePath,
+            effects: [],
+        });
+        return {
+            fileName: keyframe.fileName,
+            nodePath: keyframe.nodePath,
+            props: status.props,
+        };
+    });
+    const astByPath = new Map();
+    const effectResults = resolvedEffectKeyframes.map((keyframe) => {
+        var _a;
+        const output = outputByPath.get(keyframe.absolutePath);
+        if (!output) {
+            throw new Error('Could not compute effect keyframe deletion status');
+        }
+        const ast = (_a = astByPath.get(keyframe.absolutePath)) !== null && _a !== void 0 ? _a : (0, parse_ast_1.parseAst)(output);
+        astByPath.set(keyframe.absolutePath, ast);
+        const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, keyframe.sequenceNodePath.nodePath);
+        if (!jsx) {
+            return {
+                canUpdate: false,
+                effectIndex: keyframe.effectIndex,
+                reason: 'not-found',
+            };
+        }
+        return (0, can_update_effect_props_1.computeEffectPropStatus)({
+            jsx,
+            effectIndex: keyframe.effectIndex,
+            keys: (0, studio_shared_1.getAllSchemaKeys)(keyframe.schema),
+        });
+    });
+    return { sequenceResults, effectResults };
+};
+exports.deleteKeyframes = deleteKeyframes;
+const deleteKeyframesHandler = ({ input: { sequenceKeyframes, effectKeyframes, clientId }, remotionRoot, logLevel, }) => (0, save_props_mutex_1.withSavePropsLock)(async () => {
+    renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[delete-keyframes] Received request to delete ${sequenceKeyframes.length + effectKeyframes.length} keyframe(s)`);
+    await (0, exports.deleteKeyframes)({
+        sequenceKeyframes,
+        effectKeyframes,
+        clientId,
+        remotionRoot,
+        logLevel,
+    });
+    return { success: true };
+});
+exports.deleteKeyframesHandler = deleteKeyframesHandler;

package/dist/preview-server/routes/insert-jsx-element.d.ts

@@ -0,0 +1,3 @@
+import type { InsertJsxElementRequest, InsertJsxElementResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const insertJsxElementHandler: ApiHandler<InsertJsxElementRequest, InsertJsxElementResponse>;

package/dist/preview-server/routes/insert-jsx-element.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertJsxElementHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const file_watcher_1 = require("../../file-watcher");
+const resolve_composition_component_1 = require("../../helpers/resolve-composition-component");
+const format_log_file_location_1 = require("../format-log-file-location");
+const undo_stack_1 = require("../undo-stack");
+const log_update_1 = require("./log-updates/log-update");
+const save_props_mutex_1 = require("./save-props-mutex");
+const validateDimension = (name, value) => {
+    if (!Number.isFinite(value) || value < 1) {
+        throw new Error(`${name} must be a positive number`);
+    }
+};
+const validateElement = (element) => {
+    if (element.type === 'solid') {
+        validateDimension('width', element.width);
+        validateDimension('height', element.height);
+    }
+};
+const getElementLabel = (element) => {
+    if (element.type === 'solid') {
+        return '<Solid>';
+    }
+    throw new Error('Unsupported element type');
+};
+const insertJsxElementHandler = ({ input: { compositionFile, compositionId, element }, remotionRoot, logLevel, }) => (0, save_props_mutex_1.withSavePropsLock)(async () => {
+    try {
+        validateElement(element);
+        const elementLabel = getElementLabel(element);
+        renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[insert-jsx-element] Received request for compositionFile="${compositionFile}" compositionId="${compositionId}" element="${element.type}"`);
+        const { fileName, source, oldContents, output, formatted, logLine } = await (0, resolve_composition_component_1.insertJsxElementIntoComposition)({
+            remotionRoot,
+            compositionFile,
+            compositionId,
+            element,
+            prettierConfigOverride: null,
+        });
+        (0, undo_stack_1.pushToUndoStack)({
+            filePath: fileName,
+            oldContents,
+            newContents: output,
+            logLevel,
+            remotionRoot,
+            logLine,
+            description: {
+                undoMessage: `↩️  Added ${elementLabel}`,
+                redoMessage: `↪️  Added ${elementLabel}`,
+            },
+            entryType: 'insert-jsx-element',
+            suppressHmrOnFileRestore: false,
+        });
+        (0, undo_stack_1.suppressUndoStackInvalidation)(fileName);
+        (0, file_watcher_1.writeFileAndNotifyFileWatchers)(fileName, output, undefined);
+        const locationLabel = (0, format_log_file_location_1.formatLogFileLocation)({
+            remotionRoot,
+            absolutePath: fileName,
+            line: logLine,
+        });
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${renderer_1.RenderInternals.chalk.blueBright(`${locationLabel}`)} Added ${elementLabel}`);
+        if (!formatted) {
+            (0, log_update_1.warnAboutPrettierOnce)(logLevel);
+        }
+        renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `[insert-jsx-element] Wrote ${source}${formatted ? ' (formatted)' : ''}`);
+        (0, undo_stack_1.printUndoHint)(logLevel);
+        return {
+            success: true,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            reason: err.message,
+            stack: err.stack,
+        };
+    }
+});
+exports.insertJsxElementHandler = insertJsxElementHandler;

package/dist/preview-server/routes/reorder-effect.d.ts

@@ -0,0 +1,3 @@
+import type { ReorderEffectRequest, ReorderEffectResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const reorderEffectHandler: ApiHandler<ReorderEffectRequest, ReorderEffectResponse>;

package/dist/preview-server/routes/reorder-effect.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reorderEffectHandler = void 0;
+const node_fs_1 = require("node:fs");
+const renderer_1 = require("@remotion/renderer");
+const reorder_effect_1 = require("../../codemods/reorder-effect");
+const file_watcher_1 = require("../../file-watcher");
+const resolve_file_inside_project_1 = require("../../helpers/resolve-file-inside-project");
+const format_log_file_location_1 = require("../format-log-file-location");
+const undo_stack_1 = require("../undo-stack");
+const formatting_1 = require("./log-updates/formatting");
+const log_update_1 = require("./log-updates/log-update");
+const reorderEffectHandler = async ({ input: { fileName, sequenceNodePath, fromIndex, toIndex, clientId }, remotionRoot, logLevel, }) => {
+    try {
+        renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[reorder-effect] Received request for fileName="${fileName}" fromIndex=${fromIndex} toIndex=${toIndex}`);
+        const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName,
+            action: 'modify',
+        });
+        const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
+        const { output, formatted, effectLabel, logLine } = await (0, reorder_effect_1.reorderEffect)({
+            input: fileContents,
+            sequenceNodePath: sequenceNodePath.nodePath,
+            fromIndex,
+            toIndex,
+        });
+        (0, undo_stack_1.pushToUndoStack)({
+            filePath: absolutePath,
+            oldContents: fileContents,
+            newContents: null,
+            logLevel,
+            remotionRoot,
+            logLine,
+            description: {
+                undoMessage: `↩️  Reordering of ${effectLabel}`,
+                redoMessage: `↪️  Reordering of ${effectLabel}`,
+            },
+            entryType: 'reorder-effect',
+            suppressHmrOnFileRestore: false,
+        });
+        (0, undo_stack_1.suppressUndoStackInvalidation)(absolutePath);
+        (0, file_watcher_1.writeFileAndNotifyFileWatchers)(absolutePath, output, clientId);
+        const locationLabel = (0, format_log_file_location_1.formatLogFileLocation)({
+            remotionRoot,
+            absolutePath,
+            line: logLine,
+        });
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${renderer_1.RenderInternals.chalk.blueBright(`${locationLabel}`)} Reordered ${(0, formatting_1.attrName)(effectLabel)}`);
+        if (!formatted) {
+            (0, log_update_1.warnAboutPrettierOnce)(logLevel);
+        }
+        renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `[reorder-effect] Wrote ${fileRelativeToRoot}${formatted ? ' (formatted)' : ''}`);
+        (0, undo_stack_1.printUndoHint)(logLevel);
+        return {
+            success: true,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            reason: err.message,
+            stack: err.stack,
+        };
+    }
+};
+exports.reorderEffectHandler = reorderEffectHandler;

package/dist/preview-server/routes/subscribe-to-sequence-props.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subscribeToSequenceProps = void 0;
 const sequence_props_watchers_1 = require("../sequence-props-watchers");
-const subscribeToSequenceProps = ({ input: { fileName, line, column, keys, effects, clientId }, remotionRoot, logLevel, }) => {
+const subscribeToSequenceProps = ({ input: { fileName, line, column, nodePath, keys, effects, clientId }, remotionRoot, logLevel, }) => {
     const result = (0, sequence_props_watchers_1.subscribeToSequencePropsWatchers)({
         fileName,
         line,
         column,
+        nodePath,
         keys,
         effects,
         remotionRoot,

package/dist/preview-server/sequence-props-watchers.d.ts

@@ -1,9 +1,10 @@
 import { type SubscribeToSequencePropsResponse } from '@remotion/studio-shared';
 import type { SequenceNodePath } from 'remotion';
-export declare const subscribeToSequencePropsWatchers: ({ fileName, line, column, keys, effects, remotionRoot, clientId, logLevel, }: {
+export declare const subscribeToSequencePropsWatchers: ({ fileName, line, column, nodePath: preferredNodePath, keys, effects, remotionRoot, clientId, logLevel, }: {
     fileName: string;
     line: number;
     column: number;
+    nodePath: SequenceNodePath | null;
     keys: string[];
     effects: string[][];
     remotionRoot: string;

package/dist/preview-server/sequence-props-watchers.js

@@ -13,7 +13,26 @@ const live_events_1 = require("./live-events");
 const node_path_cache_1 = require("./node-path-cache");
 const can_update_sequence_props_1 = require("./routes/can-update-sequence-props");
 const sequencePropsWatchers = {};
-const getSequencePropsStatus = ({ fileName, line, column, keys, effects, remotionRoot, logLevel, }) => {
+const getSequencePropsStatus = ({ fileName, line, column, preferredNodePath, keys, effects, remotionRoot, logLevel, }) => {
+    if (preferredNodePath) {
+        const fromNodePath = (0, can_update_sequence_props_1.computeSequencePropsStatus)({
+            fileName,
+            nodePath: preferredNodePath,
+            keys,
+            effects,
+            remotionRoot,
+        });
+        return {
+            status: fromNodePath,
+            nodePath: {
+                absolutePath: node_path_1.default.resolve(remotionRoot, fileName),
+                nodePath: preferredNodePath,
+                sequenceKeys: keys,
+                effectKeys: effects,
+            },
+            success: true,
+        };
+    }
     // Try cached nodePath first (handles stale source maps after suppressed rebuilds)
     const cachedNodePath = (0, node_path_cache_1.getCachedNodePath)(fileName, line, column);
     if (cachedNodePath) {
@@ -47,12 +66,13 @@ const getSequencePropsStatus = ({ fileName, line, column, keys, effects, remotio
     });
     return status;
 };
-const subscribeToSequencePropsWatchers = ({ fileName, line, column, keys, effects, remotionRoot, clientId, logLevel, }) => {
+const subscribeToSequencePropsWatchers = ({ fileName, line, column, nodePath: preferredNodePath, keys, effects, remotionRoot, clientId, logLevel, }) => {
     var _a;
     const initialResult = getSequencePropsStatus({
         fileName,
         line,
         column,
+        preferredNodePath,
         keys,
         effects,
         remotionRoot,

package/dist/preview-server/undo-stack.d.ts

@@ -3,7 +3,7 @@ export interface UndoEntryDescription {
     undoMessage: string;
     redoMessage: string;
 }
-type UndoEntryType = 'visual-control' | 'default-props' | 'sequence-props' | 'effect-props' | 'delete-effect' | 'delete-jsx-node' | 'duplicate-jsx-node' | 'delete-composition' | 'rename-composition' | 'duplicate-composition';
+type UndoEntryType = 'visual-control' | 'default-props' | 'sequence-props' | 'effect-props' | 'keyframe-delete' | 'add-effect' | 'delete-effect' | 'reorder-effect' | 'delete-jsx-node' | 'duplicate-jsx-node' | 'insert-jsx-element' | 'delete-composition' | 'rename-composition' | 'duplicate-composition';
 type UndoEntrySnapshot = {
     filePath: string;
     oldContents: string;
@@ -27,12 +27,20 @@ type UndoEntry = {
     entryType: 'sequence-props';
 } | {
     entryType: 'effect-props';
+} | {
+    entryType: 'keyframe-delete';
+} | {
+    entryType: 'add-effect';
 } | {
     entryType: 'delete-effect';
+} | {
+    entryType: 'reorder-effect';
 } | {
     entryType: 'delete-jsx-node';
 } | {
     entryType: 'duplicate-jsx-node';
+} | {
+    entryType: 'insert-jsx-element';
 } | {
     entryType: 'delete-composition';
 } | {

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/studio-server"
 	},
 	"name": "@remotion/studio-server",
-	"version": "4.0.470",
+	"version": "4.0.471",
 	"description": "Run a Remotion Studio with a server backend",
 	"main": "dist",
 	"scripts": {
@@ -27,11 +27,11 @@
 		"@babel/parser": "7.24.1",
 		"semver": "7.5.3",
 		"prettier": "3.8.1",
-		"remotion": "4.0.470",
+		"remotion": "4.0.471",
 		"recast": "0.23.11",
-		"@remotion/bundler": "4.0.470",
-		"@remotion/renderer": "4.0.470",
-		"@remotion/studio-shared": "4.0.470",
+		"@remotion/bundler": "4.0.471",
+		"@remotion/renderer": "4.0.471",
+		"@remotion/studio-shared": "4.0.471",
 		"memfs": "3.4.3",
 		"open": "8.4.2"
 	},
@@ -39,7 +39,7 @@
 		"ast-types": "0.16.1",
 		"react": "19.2.3",
 		"@types/semver": "7.5.3",
-		"@remotion/eslint-config-internal": "4.0.470",
+		"@remotion/eslint-config-internal": "4.0.471",
 		"eslint": "9.19.0",
 		"@types/node": "20.12.14",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"