@remotion/studio-server 4.0.537 → 4.0.539

package/dist/preview-server/routes/duplicate-jsx-node.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duplicateJsxNodeHandler = void 0;
+const node_fs_1 = require("node:fs");
+const codemods_1 = require("@remotion/codemods");
+const renderer_1 = require("@remotion/renderer");
+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 sequence_node_path_mutation_1 = require("../sequence-node-path-mutation");
+const undo_stack_1 = require("../undo-stack");
+const source_file_write_queue_1 = require("./source-file-write-queue");
+const duplicateJsxNodeHandler = ({ input: { nodes }, remotionRoot, logLevel }) => {
+    return (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
+        var _a;
+        try {
+            if (nodes.length === 0) {
+                throw new Error('No JSX nodes were specified for duplication');
+            }
+            renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[duplicate-jsx-node] Received request to duplicate ${nodes.length} JSX node${nodes.length === 1 ? '' : 's'}`);
+            const itemsByFileName = new Map();
+            for (const item of nodes) {
+                const fileItems = (_a = itemsByFileName.get(item.fileName)) !== null && _a !== void 0 ? _a : [];
+                fileItems.push(item);
+                itemsByFileName.set(item.fileName, fileItems);
+            }
+            const updates = await Promise.all([...itemsByFileName.entries()].map(async ([fileName, fileItems]) => {
+                var _a;
+                var _b;
+                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 result = await (0, codemods_1.duplicateJsxNodes)({
+                    project: {
+                        files: { [absolutePath]: fileContents },
+                        rootDir: remotionRoot,
+                    },
+                    nodes: fileItems.map((item) => ({
+                        filePath: absolutePath,
+                        nodePath: item.nodePath,
+                    })),
+                });
+                const output = (_b = (_a = result.changes[0]) === null || _a === void 0 ? void 0 : _a.nextContents) !== null && _b !== void 0 ? _b : fileContents;
+                const { nodeLabels, logLines } = result.editDetails[0];
+                const nodePathRemappings = result.nodePathRemappings.map(({ oldNodePath, newNodePath }) => ({ oldNodePath, newNodePath }));
+                return {
+                    absolutePath,
+                    fileRelativeToRoot,
+                    fileContents,
+                    logLine: Math.min(...logLines),
+                    nodeLabels,
+                    nodePathRemappings,
+                    output,
+                };
+            }));
+            const nodePathMutation = (0, sequence_node_path_mutation_1.broadcastSequenceNodePathMutation)(updates.map((update) => ({
+                absolutePath: update.absolutePath,
+                remappings: update.nodePathRemappings,
+            })), null);
+            const duplicatedNodeDescription = nodes.length === 1
+                ? updates[0].nodeLabels[0]
+                : `${nodes.length} JSX nodes`;
+            (0, undo_stack_1.pushTransactionToUndoStack)({
+                snapshots: updates.map((update) => ({
+                    filePath: update.absolutePath,
+                    oldContents: update.fileContents,
+                    newContents: null,
+                    logLine: update.logLine,
+                    nodePathRemappings: update.nodePathRemappings,
+                })),
+                logLevel,
+                remotionRoot,
+                description: {
+                    undoMessage: `↩️  Duplication of ${duplicatedNodeDescription}`,
+                    redoMessage: `↪️  Duplication of ${duplicatedNodeDescription}`,
+                },
+                entryType: 'duplicate-jsx-node',
+                suppressHmrOnFileRestore: false,
+                undoRedoNavigation: null,
+            });
+            for (const update of updates) {
+                (0, undo_stack_1.suppressUndoStackInvalidation)(update.absolutePath);
+                (0, file_watcher_1.writeFileAndNotifyFileWatchers)({
+                    file: update.absolutePath,
+                    content: update.output,
+                    originatorClientId: undefined,
+                    metadata: { skipSequencePropsUpdate: true },
+                });
+                const locationLabel = (0, format_log_file_location_1.formatLogFileLocation)({
+                    remotionRoot,
+                    absolutePath: update.absolutePath,
+                    line: update.logLine,
+                });
+                const fileDescription = update.nodeLabels.length === 1
+                    ? update.nodeLabels[0]
+                    : `${update.nodeLabels.length} JSX nodes`;
+                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${(0, source_file_write_queue_1.getCodemodTimingPrefix)(logLevel)}${renderer_1.RenderInternals.chalk.blueBright(`${locationLabel}`)} Duplicated ${fileDescription}`);
+                renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `[duplicate-jsx-node] Wrote ${update.fileRelativeToRoot}`);
+            }
+            (0, undo_stack_1.printUndoHint)(logLevel);
+            return {
+                success: true,
+                nodePathMutation,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                reason: err.message,
+                stack: err.stack,
+            };
+        }
+    });
+};
+exports.duplicateJsxNodeHandler = duplicateJsxNodeHandler;

package/dist/preview-server/routes/element-install-plan.d.ts

@@ -1,7 +1,7 @@
-import type { ElementInstallExpectedFileState, PrepareElementInstallRequest } from '@remotion/studio-shared';
+import type { ElementInstallExpectedFileState, InsertElementRequest, PrepareElementInstallRequest } from '@remotion/studio-shared';
 export declare const getElementSourceHash: (source: string) => string;
-export declare const validateElementInstallPosition: (position: import("@remotion/studio-shared").InsertableCompositionElementPosition | null) => void;
-export declare const validateElementForInstallation: (element: import("@remotion/studio-shared").InstallableElement) => void;
+export declare const validateElementInstallPosition: (position: InsertElementRequest['position']) => void;
+export declare const validateElementForInstallation: (element: InsertElementRequest['element']) => void;
 export declare const makeRelativeElementImportPath: ({ fromFile, toFile, }: {
     fromFile: string;
     toFile: string;

package/dist/preview-server/routes/find-in-file.d.ts

@@ -1,12 +1,5 @@
+import { CodemodsInternals } from '@remotion/codemods';
 import type { FindInFileRequest, FindInFileResponse } from '@remotion/studio-shared';
 import type { ApiHandler } from '../api-types';
-export declare const findSearchPosition: ({ contents, lineNumber, columnNumber, search, }: {
-    contents: string;
-    lineNumber: number;
-    columnNumber: number;
-    search: string;
-}) => {
-    lineNumber: number;
-    columnNumber: number;
-};
+export declare const { findSearchPosition }: typeof CodemodsInternals;
 export declare const findInFileHandler: ApiHandler<FindInFileRequest, FindInFileResponse>;

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

@@ -79,10 +79,7 @@ const insertElementHandler = async ({ input: { compositionFile, compositionId, c
             const componentOwnsSequence = installationMode === 'component-owned-sequence';
             if (componentOwnsSequence &&
                 element.initialProps !== null &&
-                ['from', 'durationInFrames', 'name'].some((prop) => {
-                    var _a;
-                    return Object.hasOwn((_a = element.initialProps) !== null && _a !== void 0 ? _a : {}, prop);
-                })) {
+                ['from', 'durationInFrames', 'name'].some((prop) => { var _a; return Object.hasOwn((_a = element.initialProps) !== null && _a !== void 0 ? _a : {}, prop); })) {
                 throw new Error('Component-owned Element initial props must not override from, durationInFrames, or name');
             }
             if (componentOwnsSequence &&

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

@@ -0,0 +1,3 @@
+import { type InsertJsxElementRequest, type 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,231 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertJsxElementHandler = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const renderer_1 = require("@remotion/renderer");
+const studio_protocol_1 = require("@remotion/studio-protocol");
+const studio_shared_1 = require("@remotion/studio-shared");
+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 sequence_node_path_mutation_1 = require("../sequence-node-path-mutation");
+const undo_stack_1 = require("../undo-stack");
+const source_file_write_queue_1 = require("./source-file-write-queue");
+const validateDimension = (name, value) => {
+    if (!Number.isFinite(value) || value < 1) {
+        throw new Error(`${name} must be a positive number`);
+    }
+};
+const validatePosition = (position) => {
+    if (position === null) {
+        return;
+    }
+    if (!Number.isFinite(position.x) || !Number.isFinite(position.y)) {
+        throw new Error('Position must be finite');
+    }
+};
+const isInsideRemotionRoot = ({ fileName, remotionRoot, }) => {
+    const relativePath = node_path_1.default.relative(remotionRoot, fileName);
+    return !relativePath.startsWith('..') && !node_path_1.default.isAbsolute(relativePath);
+};
+const hasParentDirectorySegment = (fileName) => {
+    return fileName.split('/').includes('..');
+};
+const validateCompositionFile = ({ compositionFile, remotionRoot, }) => {
+    if (!compositionFile ||
+        compositionFile.includes('\0') ||
+        compositionFile.includes('\\') ||
+        compositionFile.startsWith('/') ||
+        hasParentDirectorySegment(compositionFile)) {
+        throw new Error('Unsupported composition file');
+    }
+    const resolved = node_path_1.default.resolve(remotionRoot, compositionFile);
+    if (!isInsideRemotionRoot({ fileName: resolved, remotionRoot })) {
+        throw new Error('Unsupported composition file');
+    }
+};
+const validateElement = (element, remotionRoot) => {
+    validatePosition(element.position);
+    if (element.type === 'solid') {
+        validateDimension('width', element.width);
+        validateDimension('height', element.height);
+        return;
+    }
+    if (element.type === 'svg') {
+        if (typeof element.markup !== 'string' || element.markup.trim() === '') {
+            throw new Error('SVG markup must be a non-empty string');
+        }
+        return;
+    }
+    if (element.type === 'asset') {
+        if (element.srcType === 'remote') {
+            if (!(0, studio_shared_1.isUrl)(element.src)) {
+                throw new Error('Remote asset source must be a URL');
+            }
+        }
+        else if (!element.src || element.src.includes('\\')) {
+            throw new Error('Asset path must be a static file path');
+        }
+        if (element.dimensions) {
+            validateDimension('width', element.dimensions.width);
+            validateDimension('height', element.dimensions.height);
+        }
+        if (element.durationInFrames !== null) {
+            validateDimension('durationInFrames', element.durationInFrames);
+        }
+        return;
+    }
+    if (element.type === 'component') {
+        if (!studio_protocol_1.StudioProtocolInternals.isComponentIdentifier(element.componentName)) {
+            throw new Error('Unsupported component name');
+        }
+        if (!studio_protocol_1.StudioProtocolInternals.isComponentIdentifier(element.importName)) {
+            throw new Error('Unsupported component import name');
+        }
+        if (!studio_protocol_1.StudioProtocolInternals.isComponentImportPath(element.importPath)) {
+            throw new Error('Unsupported component import path');
+        }
+        if (!studio_protocol_1.StudioProtocolInternals.areComponentProps(element.props)) {
+            throw new Error('Unsupported component props');
+        }
+        return;
+    }
+    if (element.type === 'composition') {
+        if (typeof element.compositionId !== 'string' || !element.compositionId) {
+            throw new Error('Unsupported composition ID');
+        }
+        if (typeof element.compositionFile !== 'string') {
+            throw new Error('Unsupported composition file');
+        }
+        validateCompositionFile({
+            compositionFile: element.compositionFile,
+            remotionRoot,
+        });
+        validateDimension('width', element.width);
+        validateDimension('height', element.height);
+        validateDimension('durationInFrames', element.durationInFrames);
+        const parsedProps = JSON.parse(element.serializedResolvedPropsWithCustomSchema);
+        if (typeof parsedProps !== 'object' ||
+            parsedProps === null ||
+            Array.isArray(parsedProps)) {
+            throw new Error('Resolved composition props must be an object');
+        }
+        return;
+    }
+    throw new Error('Unsupported element type');
+};
+const getElementLabel = (element) => {
+    if (element.type === 'solid') {
+        return '<Solid>';
+    }
+    if (element.type === 'svg') {
+        return '<Interactive.Svg>';
+    }
+    if (element.type === 'asset') {
+        if (element.assetType === 'image') {
+            return '<CanvasImage>';
+        }
+        if (element.assetType === 'video') {
+            return '<Video>';
+        }
+        if (element.assetType === 'gif') {
+            return '<Gif>';
+        }
+        if (element.assetType === 'animated-image') {
+            return '<AnimatedImage>';
+        }
+        if (element.assetType === 'audio') {
+            return '<Audio>';
+        }
+    }
+    if (element.type === 'component') {
+        return `<${element.componentName}>`;
+    }
+    if (element.type === 'composition') {
+        return `composition "${element.compositionId}"`;
+    }
+    throw new Error('Unsupported element type');
+};
+const insertJsxElementHandler = ({ input: { compositionFile, compositionId, element, from }, remotionRoot, logLevel, }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
+    try {
+        validateElement(element, remotionRoot);
+        if (from !== null &&
+            (!Number.isInteger(from) || !Number.isFinite(from) || from < 0)) {
+            throw new Error('from must be a non-negative integer');
+        }
+        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, insertedNodePath, logLine, nodePathRemappings, } = await (0, resolve_composition_component_1.insertJsxElementIntoComposition)({
+            remotionRoot,
+            compositionFile,
+            compositionId,
+            element,
+            from,
+            prettierConfigOverride: null,
+            sourceFileOverrides: null,
+        });
+        const nodePathMutation = (0, sequence_node_path_mutation_1.broadcastSequenceNodePathMutation)([
+            {
+                absolutePath: fileName,
+                remappings: nodePathRemappings,
+            },
+        ], insertedNodePath === null
+            ? null
+            : {
+                absolutePath: fileName,
+                compositionId,
+                nodePath: insertedNodePath,
+            });
+        if (insertedNodePath === null) {
+            renderer_1.RenderInternals.Log.warn({ indent: false, logLevel }, 'Could not determine the inserted JSX element node path. Skipping automatic selection.');
+        }
+        (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,
+            nodePathRemappings,
+        });
+        (0, undo_stack_1.suppressUndoStackInvalidation)(fileName);
+        (0, file_watcher_1.writeFileAndNotifyFileWatchers)({
+            file: fileName,
+            content: output,
+            originatorClientId: undefined,
+            metadata: { skipSequencePropsUpdate: true },
+        });
+        const locationLabel = (0, format_log_file_location_1.formatLogFileLocation)({
+            remotionRoot,
+            absolutePath: fileName,
+            line: logLine,
+        });
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${(0, source_file_write_queue_1.getCodemodTimingPrefix)(logLevel)}${renderer_1.RenderInternals.chalk.blueBright(`${locationLabel}`)} Added ${elementLabel}`);
+        renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `[insert-jsx-element] Wrote ${source}`);
+        (0, undo_stack_1.printUndoHint)(logLevel);
+        return {
+            success: true,
+            insertedNodePath: insertedNodePath === null
+                ? null
+                : { absolutePath: fileName, nodePath: insertedNodePath },
+            nodePathMutation,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            reason: err.message,
+            stack: err.stack,
+        };
+    }
+});
+exports.insertJsxElementHandler = insertJsxElementHandler;

package/dist/preview-server/routes/insert-video-layers.d.ts

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

package/dist/preview-server/routes/insert-video-layers.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertVideoLayersHandler = void 0;
+const node_fs_1 = require("node:fs");
+const renderer_1 = require("@remotion/renderer");
+const insert_video_layers_1 = require("../../codemods/insert-video-layers");
+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 sequence_node_path_mutation_1 = require("../sequence-node-path-mutation");
+const undo_stack_1 = require("../undo-stack");
+const source_file_write_queue_1 = require("./source-file-write-queue");
+const insertVideoLayersHandler = ({ input: { fileName, nodePath, baseSrc, foregroundSrc }, remotionRoot, logLevel, }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(() => {
+    var _a;
+    try {
+        const { absolutePath } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName,
+            action: 'modify',
+        });
+        const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
+        const { output, logLine, nodePathRemappings } = (0, insert_video_layers_1.insertVideoLayers)({
+            input: fileContents,
+            nodePath,
+            baseSrc,
+            foregroundSrc,
+        });
+        const nodePathMutation = (0, sequence_node_path_mutation_1.broadcastSequenceNodePathMutation)([{ absolutePath, remappings: nodePathRemappings }], null);
+        (0, undo_stack_1.pushToUndoStack)({
+            filePath: absolutePath,
+            oldContents: fileContents,
+            newContents: null,
+            logLevel,
+            remotionRoot,
+            logLine,
+            description: {
+                undoMessage: '↩️  Insertion of separated video layers',
+                redoMessage: '↪️  Insertion of separated video layers',
+            },
+            entryType: 'insert-video-layers',
+            suppressHmrOnFileRestore: false,
+            nodePathRemappings,
+        });
+        (0, undo_stack_1.suppressUndoStackInvalidation)(absolutePath);
+        (0, file_watcher_1.writeFileAndNotifyFileWatchers)({
+            file: absolutePath,
+            content: output,
+            originatorClientId: undefined,
+            metadata: { skipSequencePropsUpdate: true },
+        });
+        const locationLabel = (0, format_log_file_location_1.formatLogFileLocation)({
+            remotionRoot,
+            absolutePath,
+            line: logLine,
+        });
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${(0, source_file_write_queue_1.getCodemodTimingPrefix)(logLevel)}${renderer_1.RenderInternals.chalk.blueBright(locationLabel)} Inserted separated video layers`);
+        (0, undo_stack_1.printUndoHint)(logLevel);
+        return Promise.resolve({ success: true, nodePathMutation });
+    }
+    catch (error) {
+        return Promise.resolve({
+            success: false,
+            reason: error.message,
+            stack: (_a = error.stack) !== null && _a !== void 0 ? _a : '',
+        });
+    }
+});
+exports.insertVideoLayersHandler = insertVideoLayersHandler;

package/dist/preview-server/routes/install-dependency.d.ts

@@ -1,18 +1,6 @@
 import { type InstallPackageRequest, type InstallPackageResponse, type PackageInstallSpec } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
 export declare const getPackageInstallSpec: (dependency: PackageInstallSpec) => string;
-export declare const handleInstallPackage: ({ logLevel, remotionRoot, input: { dependencies }, invalidateBundle, }: {
-    input: InstallPackageRequest;
-    entryPoint: string;
-    remotionRoot: string;
-    request: import("http").IncomingMessage;
-    response: import("http").ServerResponse<import("http").IncomingMessage>;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
-    methods: import("../api-types").QueueMethods;
-    publicDir: string;
-    binariesDirectory: string | null;
-    configFile: string | null;
-    getDefaultCodingAgent: () => "claude-code" | "codex" | "copilot" | "cursor" | null;
-    getDefaultEditor: () => import("@remotion/renderer").DefaultEditor | null;
-} & {
+export declare const handleInstallPackage: ({ logLevel, remotionRoot, input: { dependencies }, invalidateBundle, }: Parameters<ApiHandler<InstallPackageRequest, InstallPackageResponse>>[0] & {
     readonly invalidateBundle: () => Promise<void>;
 }) => Promise<InstallPackageResponse>;

package/dist/preview-server/routes/log-updates/log-effect-update.d.ts

@@ -1,3 +1,4 @@
+import type { LogLevel } from '@remotion/renderer';
 import type { PropDelta } from './formatting';
 export declare const logEffectUpdate: ({ fileRelativeToRoot, line, effectName, propKey, oldValueString, newValueString, defaultValueString, formatted, logLevel, removedProps, addedProps, }: {
     fileRelativeToRoot: string;
@@ -8,7 +9,7 @@ export declare const logEffectUpdate: ({ fileRelativeToRoot, line, effectName, p
     newValueString: string;
     defaultValueString: string | null;
     formatted: boolean;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
     removedProps: PropDelta[];
     addedProps: PropDelta[];
 }) => void;

package/dist/preview-server/routes/log-updates/log-update.d.ts

@@ -1,5 +1,6 @@
+import type { LogLevel } from '@remotion/renderer';
 import type { PropDelta } from './formatting';
-export declare const warnAboutPrettierOnce: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
+export declare const warnAboutPrettierOnce: (logLevel: LogLevel) => void;
 export declare const normalizeQuotes: (str: string) => string;
 export declare const logUpdate: ({ fileRelativeToRoot, line, key, oldValueString, newValueString, defaultValueString, formatted, logLevel, removedProps, addedProps, }: {
     fileRelativeToRoot: string;
@@ -9,7 +10,7 @@ export declare const logUpdate: ({ fileRelativeToRoot, line, key, oldValueString
     newValueString: string;
     defaultValueString: string | null;
     formatted: boolean;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
     removedProps: PropDelta[];
     addedProps: PropDelta[];
 }) => void;

package/dist/preview-server/routes/move-keyframes.d.ts

@@ -1,7 +1,8 @@
+import type { LogLevel } from '@remotion/renderer';
 import type { MoveKeyframesRequest, MoveKeyframesResponse } from '@remotion/studio-shared';
 import type { ApiHandler } from '../api-types';
 export declare const moveKeyframes: ({ sequenceKeyframes, effectKeyframes, clientId, remotionRoot, logLevel, }: MoveKeyframesRequest & {
     remotionRoot: string;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
 }) => Promise<void>;
 export declare const moveKeyframesHandler: ApiHandler<MoveKeyframesRequest, MoveKeyframesResponse>;

package/dist/preview-server/routes/open-in-editor.d.ts

@@ -1,8 +1,8 @@
-import type { DefaultEditor } from '@remotion/renderer';
+import type { DefaultEditor, LogLevel } from '@remotion/renderer';
 import type { OpenInEditorRequest, OpenInEditorResponse } from '@remotion/studio-shared';
 import type { ApiHandler } from '../api-types';
 export declare const getEditorName: ({ getDefaultEditor, logLevel, }: {
     getDefaultEditor: () => DefaultEditor | null;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
 }) => Promise<string | null>;
 export declare const openInEditorHandler: ApiHandler<OpenInEditorRequest, OpenInEditorResponse>;

package/dist/preview-server/routes/remotion-skills-info.d.ts

@@ -2,7 +2,7 @@ import type { GetRemotionSkillsInfoRequest, GetRemotionSkillsInfoResponse, OpenR
 import type { ApiHandler } from '../api-types';
 export declare const getRemotionSkillsInfo: ({ remotionRoot, homeDirectory, }: {
     remotionRoot: string;
-    homeDirectory?: string | undefined;
+    homeDirectory?: string;
 }) => GetRemotionSkillsInfoResponse;
 export declare const remotionSkillsInfoHandler: ApiHandler<GetRemotionSkillsInfoRequest, GetRemotionSkillsInfoResponse>;
 export declare const openRemotionSkillHandler: ApiHandler<OpenRemotionSkillRequest, void>;

package/dist/preview-server/routes/save-multiple-effect-props.js

@@ -141,6 +141,9 @@ const saveMultipleEffectPropsHandler = ({ input: { edits, clientId, undoLabel, r
             edit,
         ])).values(),
     ];
+    const statusAsts = new Map();
+    // Share binding analysis, but resolve each target's video configuration below.
+    const statusIdentifiers = new Map();
     const results = statusTargets.map((edit) => {
         const { absolutePath } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
             remotionRoot,
@@ -151,24 +154,38 @@ const saveMultipleEffectPropsHandler = ({ input: { edits, clientId, undoLabel, r
         if (!output) {
             throw new Error('Could not compute effect prop edit status');
         }
-        const ast = (0, parse_ast_1.parseAst)(output);
+        let ast = statusAsts.get(absolutePath);
+        if (!ast) {
+            ast = (0, parse_ast_1.parseAst)(output);
+            statusAsts.set(absolutePath, ast);
+        }
         const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, edit.sequenceNodePath.nodePath);
-        const status = jsx
-            ? (0, can_update_effect_props_1.computeEffectPropStatus)({
+        let status;
+        if (jsx) {
+            const keys = (0, studio_shared_1.getAllSchemaKeys)(edit.schema);
+            let identifiers = statusIdentifiers.get(absolutePath);
+            if (!identifiers) {
+                identifiers = (0, video_config_values_1.getVideoConfigIdentifiers)({ ast });
+                statusIdentifiers.set(absolutePath, identifiers);
+            }
+            status = (0, can_update_effect_props_1.computeEffectPropStatus)({
                 ast,
                 jsx,
                 effectIndex: edit.effectIndex,
-                keys: (0, studio_shared_1.getAllSchemaKeys)(edit.schema),
-                videoConfigValues: (0, video_config_values_1.getVideoConfigIdentifierValues)({
-                    ast,
+                keys,
+                videoConfigValues: (0, video_config_values_1.resolveVideoConfigIdentifierValues)({
+                    identifiers,
                     videoConfigValues: edit.sequenceNodePath.videoConfigValues,
                 }),
-            })
-            : {
+            });
+        }
+        else {
+            status = {
                 canUpdate: false,
                 effectIndex: edit.effectIndex,
                 reason: 'not-found',
             };
+        }
         return {
             fileName: edit.fileName,
             sequenceNodePath: edit.sequenceNodePath,

package/dist/preview-server/routes/save-sequence-props.d.ts

@@ -13,10 +13,10 @@ type ResolvedSequencePropEdit = {
     schema: SaveSequencePropEdit['schema'];
     sourceEdit: SaveSequencePropEdit['sourceEdit'];
 };
-export declare const convertSequencePropEditToCodemodChange: (edit: Pick<ResolvedSequencePropEdit, "defaultValue" | "key" | "nodePath" | "schema" | "sourceEdit" | "value">) => SequencePropsNodeUpdate;
+export declare const convertSequencePropEditToCodemodChange: (edit: Pick<ResolvedSequencePropEdit, 'nodePath' | 'key' | 'value' | 'defaultValue' | 'schema' | 'sourceEdit'>) => SequencePropsNodeUpdate;
 export declare const shouldSuppressHmrForSequencePropEdits: (edits: readonly {
     key: string;
-    sourceEdit?: import("@remotion/studio-shared").SaveSequencePropSourceEdit | null | undefined;
+    sourceEdit?: SaveSequencePropEdit['sourceEdit'];
 }[]) => boolean;
 export declare const saveSequencePropsHandler: ApiHandler<SaveSequencePropsRequest, SaveSequencePropsResponse>;
 export {};

package/dist/preview-server/routes/source-file-write-queue.d.ts

@@ -1,2 +1,3 @@
-export declare const getCodemodTimingPrefix: (logLevel: "error" | "info" | "trace" | "verbose" | "warn") => string;
-export declare const withSourceFileWriteQueue: <T>(fn: () => T | Promise<T>) => Promise<T>;
+import type { LogLevel } from '@remotion/renderer';
+export declare const getCodemodTimingPrefix: (logLevel: LogLevel) => string;
+export declare const withSourceFileWriteQueue: <T>(fn: () => Promise<T> | T) => Promise<T>;

package/dist/preview-server/routes/split-jsx-sequence.d.ts

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