@remotion/studio-server 4.0.502 → 4.0.504

package/dist/preview-server/routes/delete-sequence-keyframe.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSequenceKeyframeHandler = void 0;
+const node_fs_1 = require("node:fs");
+const renderer_1 = require("@remotion/renderer");
+const studio_shared_1 = require("@remotion/studio-shared");
+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_sequence_props_1 = require("./can-update-sequence-props");
+const log_update_1 = require("./log-updates/log-update");
+const save_props_mutex_1 = require("./save-props-mutex");
+const deleteSequenceKeyframeHandler = ({ input: { fileName, nodePath, key, frame, schema, clientId }, remotionRoot, logLevel, }) => (0, save_props_mutex_1.withSavePropsLock)(async () => {
+    renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[delete-sequence-keyframe] Received request for fileName="${fileName}" key="${key}" frame=${frame}`);
+    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, oldValueStrings, newValueStrings, formatted, logLine } = await (0, update_keyframes_1.updateSequenceKeyframes)({
+        input: fileContents,
+        nodePath: nodePath.nodePath,
+        updates: [
+            {
+                key,
+                operation: {
+                    type: 'remove',
+                    frame,
+                },
+            },
+        ],
+    });
+    const oldValueString = oldValueStrings[0];
+    const newValueString = newValueStrings[0];
+    const undoPropChange = `${key} keyframe restored at frame ${frame}`;
+    const redoPropChange = `${key} keyframe deleted at frame ${frame}`;
+    (0, undo_stack_1.pushToUndoStack)({
+        filePath: absolutePath,
+        oldContents: fileContents,
+        newContents: null,
+        logLevel,
+        remotionRoot,
+        logLine,
+        description: {
+            undoMessage: `↩️  ${undoPropChange}`,
+            redoMessage: `↪️  ${redoPropChange}`,
+        },
+        entryType: 'sequence-props',
+        suppressHmrOnFileRestore: true,
+    });
+    (0, undo_stack_1.suppressUndoStackInvalidation)(absolutePath);
+    (0, watch_ignore_next_change_1.suppressBundlerUpdateForFile)(absolutePath);
+    (0, file_watcher_1.writeFileAndNotifyFileWatchers)(absolutePath, output, clientId);
+    (0, log_update_1.logUpdate)({
+        fileRelativeToRoot,
+        line: logLine,
+        key,
+        oldValueString,
+        newValueString,
+        defaultValueString: null,
+        formatted,
+        logLevel,
+        removedProps: [],
+        addedProps: [],
+    });
+    (0, undo_stack_1.printUndoHint)(logLevel);
+    const status = (0, can_update_sequence_props_1.computeSequencePropsStatusFromContent)({
+        fileContents: output,
+        keys: (0, studio_shared_1.getAllSchemaKeys)(schema),
+        nodePath: nodePath.nodePath,
+        effects: [],
+    });
+    return {
+        canUpdate: true,
+        props: status.props,
+        results: [{ fileName, nodePath, props: status.props }],
+    };
+});
+exports.deleteSequenceKeyframeHandler = deleteSequenceKeyframeHandler;

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

@@ -0,0 +1,33 @@
+import type { ElementInstallExpectedFileState, PrepareElementInstallRequest } from '@remotion/studio-shared';
+export declare const normalizeElementSourceForComparison: (source: string) => string;
+export declare const getElementSourceHash: (source: string) => string;
+export declare const validateElementInstallPosition: (position: import("@remotion/studio-shared").InsertableCompositionElementPosition | null) => void;
+export declare const validateElementForInstallation: (element: {
+    dependencies: import("@remotion/studio-protocol").ElementDependency[];
+    durationInFrames?: number | undefined;
+    slug: string;
+    displayName: string;
+    sourceCode: string;
+    dimensions: import("@remotion/studio-protocol").ComponentDimensions | null;
+}) => void;
+export declare const makeRelativeElementImportPath: ({ fromFile, toFile, }: {
+    fromFile: string;
+    toFile: string;
+}) => string;
+export declare const getElementInstallPlan: ({ compositionFile, compositionId, element, remotionRoot, }: PrepareElementInstallRequest & {
+    remotionRoot: string;
+}) => Promise<{
+    componentName: string;
+    elementFileExists: boolean;
+    elementFileName: string;
+    existingElementSource: string | null;
+    expectedFileState: ElementInstallExpectedFileState;
+    filePath: string;
+    importPath: string;
+    location: import("../../helpers/resolve-composition-component").ResolvedCompositionComponentWithFile;
+    safePaths: {
+        compositionFileName: string;
+        elementFileName: string;
+        remotionRoot: string;
+    };
+}>;

package/dist/preview-server/routes/element-install-plan.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementInstallPlan = exports.makeRelativeElementImportPath = exports.validateElementForInstallation = exports.validateElementInstallPosition = exports.getElementSourceHash = exports.normalizeElementSourceForComparison = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const studio_protocol_1 = require("@remotion/studio-protocol");
+const resolve_composition_component_1 = require("../../helpers/resolve-composition-component");
+const safe_element_install_path_1 = require("./safe-element-install-path");
+const normalizeElementSourceForComparison = (source) => {
+    return source.replace(/\r\n/g, '\n').trim();
+};
+exports.normalizeElementSourceForComparison = normalizeElementSourceForComparison;
+const getElementSourceHash = (source) => {
+    return (0, node_crypto_1.createHash)('sha256').update(source).digest('hex');
+};
+exports.getElementSourceHash = getElementSourceHash;
+const validateElementInstallPosition = (position) => {
+    if (position === null) {
+        return;
+    }
+    if (!Number.isFinite(position.x) || !Number.isFinite(position.y)) {
+        throw new Error('Position must be finite');
+    }
+};
+exports.validateElementInstallPosition = validateElementInstallPosition;
+const validateDimensions = (dimensions) => {
+    if (dimensions === null) {
+        return;
+    }
+    if (!Number.isFinite(dimensions.width) ||
+        !Number.isFinite(dimensions.height) ||
+        dimensions.width <= 0 ||
+        dimensions.height <= 0) {
+        throw new Error('Element dimensions must be positive finite numbers');
+    }
+};
+const validateElementForInstallation = (element) => {
+    if (studio_protocol_1.StudioProtocolInternals.makeElementFileNameFromSlug(element.slug) === null) {
+        throw new Error('Element slug must produce a safe lowercase .tsx file name');
+    }
+    if (typeof element.sourceCode !== 'string' ||
+        element.sourceCode.trim().length === 0 ||
+        element.sourceCode.length > 200000) {
+        throw new Error('Unsupported Element source code');
+    }
+    if (studio_protocol_1.StudioProtocolInternals.getElementComponentNameFromSourceCode(element.sourceCode) === null) {
+        throw new Error('Element source must export exactly one named component');
+    }
+    validateDimensions(element.dimensions);
+};
+exports.validateElementForInstallation = validateElementForInstallation;
+const makeRelativeElementImportPath = ({ fromFile, toFile, }) => {
+    const withoutExtension = toFile.replace(/\.tsx$/, '');
+    let relative = node_path_1.default
+        .relative(node_path_1.default.dirname(fromFile), withoutExtension)
+        .split(node_path_1.default.sep)
+        .join('/');
+    if (!relative.startsWith('.')) {
+        relative = `./${relative}`;
+    }
+    return relative;
+};
+exports.makeRelativeElementImportPath = makeRelativeElementImportPath;
+const getExpectedFileState = (existingSource) => {
+    if (existingSource === null) {
+        return { exists: false };
+    }
+    return {
+        exists: true,
+        sourceHash: (0, exports.getElementSourceHash)(existingSource),
+    };
+};
+const getElementInstallPlan = async ({ compositionFile, compositionId, element, remotionRoot, }) => {
+    (0, exports.validateElementForInstallation)(element);
+    const componentName = studio_protocol_1.StudioProtocolInternals.getElementComponentNameFromSourceCode(element.sourceCode);
+    if (componentName === null) {
+        throw new Error('Element source must export exactly one named component');
+    }
+    const location = await (0, resolve_composition_component_1.resolveCompositionComponentWithFile)({
+        remotionRoot,
+        compositionFile,
+        compositionId,
+    });
+    if (!location.canAddSequence) {
+        throw new Error('Cannot insert Element into this composition component');
+    }
+    const derivedElementFileName = studio_protocol_1.StudioProtocolInternals.makeElementFileNameFromSlug(element.slug);
+    if (derivedElementFileName === null) {
+        throw new Error('Element slug must produce a safe lowercase .tsx file name');
+    }
+    const safePaths = await (0, safe_element_install_path_1.getSafeElementInstallPaths)({
+        compositionFileName: location.fileName,
+        elementFileName: node_path_1.default.resolve(node_path_1.default.dirname(location.fileName), derivedElementFileName),
+        remotionRoot,
+    });
+    const elementFileExists = (0, node_fs_1.existsSync)(safePaths.elementFileName);
+    const existingElementSource = elementFileExists
+        ? (0, node_fs_1.readFileSync)(safePaths.elementFileName, 'utf-8')
+        : null;
+    return {
+        componentName,
+        elementFileExists,
+        elementFileName: safePaths.elementFileName,
+        existingElementSource,
+        expectedFileState: getExpectedFileState(existingElementSource),
+        filePath: node_path_1.default
+            .relative(safePaths.remotionRoot, safePaths.elementFileName)
+            .split(node_path_1.default.sep)
+            .join('/'),
+        importPath: (0, exports.makeRelativeElementImportPath)({
+            fromFile: safePaths.compositionFileName,
+            toFile: safePaths.elementFileName,
+        }),
+        location,
+        safePaths,
+    };
+};
+exports.getElementInstallPlan = getElementInstallPlan;

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

@@ -1,3 +1,3 @@
-import { type InsertElementRequest, type InsertElementResponse } from '@remotion/studio-shared';
+import type { InsertElementRequest, InsertElementResponse } from '@remotion/studio-shared';
 import type { ApiHandler } from '../api-types';
 export declare const insertElementHandler: ApiHandler<InsertElementRequest, InsertElementResponse>;

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

@@ -1,138 +1,86 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertElementHandler = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
 const renderer_1 = require("@remotion/renderer");
-const studio_protocol_1 = require("@remotion/studio-protocol");
 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 element_install_plan_1 = require("./element-install-plan");
 const log_update_1 = require("./log-updates/log-update");
 const source_file_write_queue_1 = require("./source-file-write-queue");
-const validatePosition = (position) => {
-    if (position === null) {
-        return;
+const hasExpectedFileState = ({ expected, actual, }) => {
+    if (expected.exists !== actual.exists) {
+        return false;
     }
-    if (!Number.isFinite(position.x) || !Number.isFinite(position.y)) {
-        throw new Error('Position must be finite');
+    if (!expected.exists) {
+        return true;
     }
-};
-const isInside = ({ child, parent }) => {
-    const relative = node_path_1.default.relative(parent, child);
-    return (relative === '' ||
-        (!relative.startsWith('..') && !node_path_1.default.isAbsolute(relative)));
-};
-const withoutTsxExtension = (fileName) => {
-    return fileName.replace(/\.tsx$/, '');
-};
-const normalizeSourceForComparison = (source) => {
-    return source.replace(/\r\n/g, '\n').trim();
-};
-const makeRelativeImportPath = ({ fromFile, toFile, }) => {
-    const withoutExtension = withoutTsxExtension(toFile);
-    let relative = node_path_1.default
-        .relative(node_path_1.default.dirname(fromFile), withoutExtension)
-        .split(node_path_1.default.sep)
-        .join('/');
-    if (!relative.startsWith('.')) {
-        relative = `./${relative}`;
+    if (!actual.exists) {
+        return false;
     }
-    return relative;
+    return actual.sourceHash === expected.sourceHash;
 };
-const validateDimensions = (dimensions) => {
-    if (dimensions === null) {
-        return;
-    }
-    if (!Number.isFinite(dimensions.width) ||
-        !Number.isFinite(dimensions.height) ||
-        dimensions.width <= 0 ||
-        dimensions.height <= 0) {
-        throw new Error('Element dimensions must be positive finite numbers');
-    }
-};
-const validateElement = (element) => {
-    if (studio_protocol_1.StudioProtocolInternals.makeElementFileNameFromSlug(element.slug) === null) {
-        throw new Error('Element slug must produce a safe lowercase .tsx file name');
-    }
-    if (typeof element.sourceCode !== 'string' ||
-        element.sourceCode.trim().length === 0 ||
-        element.sourceCode.length > 200000) {
-        throw new Error('Unsupported Element source code');
-    }
-    if (studio_protocol_1.StudioProtocolInternals.getElementComponentNameFromSourceCode(element.sourceCode) === null) {
-        throw new Error('Element source must export exactly one named component');
-    }
-    validateDimensions(element.dimensions);
-};
-const insertElementHandler = ({ input: { compositionFile, compositionId, element, from, position, overwriteExisting, }, remotionRoot, logLevel, }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
+const insertElementHandler = ({ input: { compositionFile, compositionId, element, expectedFileState, from, position, overwriteExisting, }, remotionRoot, logLevel, }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
+    var _a;
     try {
-        validateElement(element);
-        validatePosition(position);
+        (0, element_install_plan_1.validateElementInstallPosition)(position);
         if (from !== null &&
             (!Number.isInteger(from) || !Number.isFinite(from) || from < 0)) {
             throw new Error('from must be a non-negative integer');
         }
-        const componentName = studio_protocol_1.StudioProtocolInternals.getElementComponentNameFromSourceCode(element.sourceCode);
-        if (componentName === null) {
-            throw new Error('Element source must export exactly one named component');
-        }
         renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[insert-element] Received request for compositionFile="${compositionFile}" compositionId="${compositionId}" element="${element.slug}"`);
-        const location = await (0, resolve_composition_component_1.resolveCompositionComponentWithFile)({
-            remotionRoot,
+        const plan = await (0, element_install_plan_1.getElementInstallPlan)({
             compositionFile,
             compositionId,
+            element,
+            remotionRoot,
         });
-        if (!location.canAddSequence) {
-            throw new Error('Cannot insert Element into this composition component');
-        }
-        const derivedElementFileName = studio_protocol_1.StudioProtocolInternals.makeElementFileNameFromSlug(element.slug);
-        if (derivedElementFileName === null) {
-            throw new Error('Element slug must produce a safe lowercase .tsx file name');
-        }
-        const elementFileName = node_path_1.default.resolve(node_path_1.default.dirname(location.fileName), derivedElementFileName);
-        if (!isInside({ child: elementFileName, parent: remotionRoot })) {
-            throw new Error('Element file must stay inside the Remotion project');
+        if (expectedFileState !== null &&
+            !hasExpectedFileState({
+                actual: plan.expectedFileState,
+                expected: expectedFileState,
+            })) {
+            const { existingElementSource } = plan;
+            if (existingElementSource !== null) {
+                return {
+                    success: false,
+                    type: 'file-conflict',
+                    conflict: {
+                        filePath: plan.filePath,
+                        existingSource: existingElementSource,
+                        incomingSource: element.sourceCode,
+                    },
+                };
+            }
+            throw new Error('Element source changed during installation');
         }
-        const elementFileExists = (0, node_fs_1.existsSync)(elementFileName);
-        const existingElementSource = elementFileExists
-            ? (0, node_fs_1.readFileSync)(elementFileName, 'utf-8')
-            : null;
-        const elementSourcesDiffer = existingElementSource !== null &&
-            normalizeSourceForComparison(existingElementSource) !==
-                normalizeSourceForComparison(element.sourceCode);
-        if (elementSourcesDiffer && !overwriteExisting) {
+        const elementSourcesDiffer = plan.existingElementSource !== null &&
+            (0, element_install_plan_1.normalizeElementSourceForComparison)(plan.existingElementSource) !==
+                (0, element_install_plan_1.normalizeElementSourceForComparison)(element.sourceCode);
+        if (elementSourcesDiffer &&
+            !overwriteExisting &&
+            plan.existingElementSource !== null) {
             return {
                 success: false,
                 type: 'file-conflict',
                 conflict: {
-                    filePath: node_path_1.default
-                        .relative(remotionRoot, elementFileName)
-                        .split(node_path_1.default.sep)
-                        .join('/'),
-                    existingSource: existingElementSource,
+                    filePath: plan.filePath,
+                    existingSource: plan.existingElementSource,
                     incomingSource: element.sourceCode,
                 },
             };
         }
-        const shouldWriteElementFile = !elementFileExists || elementSourcesDiffer;
-        const importPath = makeRelativeImportPath({
-            fromFile: location.fileName,
-            toFile: elementFileName,
-        });
+        const shouldWriteElementFile = !plan.elementFileExists || elementSourcesDiffer;
         const inserted = await (0, resolve_composition_component_1.insertJsxElementIntoComposition)({
             remotionRoot,
             compositionFile,
             compositionId,
             element: {
                 type: 'component',
-                componentName,
-                importName: componentName,
-                importPath,
+                componentName: plan.componentName,
+                importName: plan.componentName,
+                importPath: plan.importPath,
                 props: [],
                 position: null,
             },
@@ -140,18 +88,35 @@ const insertElementHandler = ({ input: { compositionFile, compositionId, element
             prettierConfigOverride: null,
             wrapInSequence: {
                 dimensions: element.dimensions,
+                durationInFrames: (_a = element.durationInFrames) !== null && _a !== void 0 ? _a : null,
                 from,
                 name: element.displayName,
                 position,
             },
         });
+        const finalPlan = await (0, element_install_plan_1.getElementInstallPlan)({
+            compositionFile,
+            compositionId,
+            element,
+            remotionRoot,
+        });
+        if (finalPlan.safePaths.compositionFileName !==
+            plan.safePaths.compositionFileName) {
+            throw new Error('Composition source changed during Element installation');
+        }
+        if (!hasExpectedFileState({
+            actual: finalPlan.expectedFileState,
+            expected: plan.expectedFileState,
+        })) {
+            throw new Error('Element source changed during installation');
+        }
         (0, undo_stack_1.pushTransactionToUndoStack)({
             snapshots: [
                 ...(shouldWriteElementFile
                     ? [
                         {
-                            filePath: elementFileName,
-                            oldContents: existingElementSource,
+                            filePath: plan.elementFileName,
+                            oldContents: plan.existingElementSource,
                             newContents: element.sourceCode,
                             logLine: 1,
                         },
@@ -174,11 +139,11 @@ const insertElementHandler = ({ input: { compositionFile, compositionId, element
             suppressHmrOnFileRestore: false,
         });
         if (shouldWriteElementFile) {
-            (0, undo_stack_1.suppressUndoStackInvalidation)(elementFileName);
+            (0, undo_stack_1.suppressUndoStackInvalidation)(plan.elementFileName);
         }
         (0, undo_stack_1.suppressUndoStackInvalidation)(inserted.fileName);
         if (shouldWriteElementFile) {
-            (0, file_watcher_1.writeFileAndNotifyFileWatchers)(elementFileName, element.sourceCode, undefined);
+            (0, file_watcher_1.writeFileAndNotifyFileWatchers)(plan.elementFileName, element.sourceCode, undefined);
         }
         (0, file_watcher_1.writeFileAndNotifyFileWatchers)(inserted.fileName, inserted.output, undefined);
         const compositionLocationLabel = (0, format_log_file_location_1.formatLogFileLocation)({
@@ -188,23 +153,21 @@ const insertElementHandler = ({ input: { compositionFile, compositionId, element
         });
         const elementLocationLabel = (0, format_log_file_location_1.formatLogFileLocation)({
             remotionRoot,
-            absolutePath: elementFileName,
+            absolutePath: plan.elementFileName,
             line: 1,
         });
         const elementFileAction = elementSourcesDiffer
             ? 'Overwrote existing Element source'
-            : elementFileExists
+            : plan.elementFileExists
                 ? 'Reused existing Element source'
                 : 'Created Element source';
         renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${renderer_1.RenderInternals.chalk.blueBright(elementLocationLabel)} ${elementFileAction}`);
-        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${renderer_1.RenderInternals.chalk.blueBright(compositionLocationLabel)} Added <${componentName}>`);
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${renderer_1.RenderInternals.chalk.blueBright(compositionLocationLabel)} Added <${plan.componentName}>`);
         if (!inserted.formatted) {
             (0, log_update_1.warnAboutPrettierOnce)(logLevel);
         }
         (0, undo_stack_1.printUndoHint)(logLevel);
-        return {
-            success: true,
-        };
+        return { success: true };
     }
     catch (err) {
         return {

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

@@ -1,4 +1,5 @@
+import type { ElementDependency } from '@remotion/studio-protocol';
 import { type InstallPackageRequest, type InstallPackageResponse } from '@remotion/studio-shared';
 import type { ApiHandler } from '../api-types';
-export declare const getPackageInstallSpec: (packageName: string) => string;
+export declare const getPackageInstallSpec: (dependency: string | ElementDependency) => string;
 export declare const handleInstallPackage: ApiHandler<InstallPackageRequest, InstallPackageResponse>;

package/dist/preview-server/routes/install-dependency.js

@@ -12,21 +12,26 @@ const getExtraPackageVersion = (packageName) => {
     const pkg = studio_shared_1.extraPackages.find((p) => p.name === packageName);
     return pkg ? pkg.version : null;
 };
-const getPackageInstallSpec = (packageName) => {
-    const extraVersion = getExtraPackageVersion(packageName);
-    if (extraVersion) {
-        return `${packageName}@${extraVersion}`;
-    }
-    if (packageName === 'remotion' || packageName.startsWith('@remotion/')) {
-        return `${packageName}@${version_1.VERSION}`;
-    }
-    return packageName;
+const getPackageInstallSpec = (dependency) => {
+    const { name, version } = typeof dependency === 'string'
+        ? { name: dependency, version: null }
+        : dependency;
+    const extraVersion = getExtraPackageVersion(name);
+    if (extraVersion)
+        return `${name}@${extraVersion}`;
+    if (name === 'remotion' || name.startsWith('@remotion/'))
+        return `${name}@${version_1.VERSION}`;
+    return version === null ? name : `${name}@${version}`;
 };
 exports.getPackageInstallSpec = getPackageInstallSpec;
-const handleInstallPackage = async ({ logLevel, remotionRoot, input: { packageNames } }) => {
-    for (const packageName of packageNames) {
-        if (!(0, studio_shared_1.isValidPackageName)(packageName)) {
-            return Promise.reject(new Error(`Package name ${JSON.stringify(packageName)} is invalid.`));
+const handleInstallPackage = async ({ logLevel, remotionRoot, input: { dependencies } }) => {
+    for (const dependency of dependencies) {
+        if (!(0, studio_shared_1.isValidPackageName)(dependency.name)) {
+            return Promise.reject(new Error(`Package name ${JSON.stringify(dependency.name)} is invalid.`));
+        }
+        if (dependency.version !== null &&
+            !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(dependency.version)) {
+            return Promise.reject(new Error(`Package version ${JSON.stringify(dependency.version)} is invalid.`));
         }
     }
     const manager = (0, get_package_manager_1.getPackageManager)({
@@ -36,13 +41,9 @@ const handleInstallPackage = async ({ logLevel, remotionRoot, input: { packageNa
         logLevel,
     });
     if (manager === 'unknown') {
-        throw new Error(`No lockfile was found in your project (one of ${get_package_manager_1.lockFilePaths
-            .map((p) => p.path)
-            .join(', ')}). Install dependencies using your favorite manager!`);
+        throw new Error(`No lockfile was found in your project (one of ${get_package_manager_1.lockFilePaths.map((p) => p.path).join(', ')}). Install dependencies using your favorite manager!`);
     }
-    // Remotion packages must match the Studio version and catalogued extra
-    // packages use their supported version. Other packages resolve normally.
-    const packagesWithVersions = packageNames.map(exports.getPackageInstallSpec);
+    const packagesWithVersions = dependencies.map(exports.getPackageInstallSpec);
     const command = (0, install_command_1.getInstallCommand)({
         manager: manager.manager,
         packages: packagesWithVersions,
@@ -54,34 +55,22 @@ const handleInstallPackage = async ({ logLevel, remotionRoot, input: { packageNa
     try {
         await new Promise((resolve, reject) => {
             const cmd = (0, node_child_process_1.spawn)(manager.manager, command, (0, package_manager_spawn_options_1.getPackageManagerSpawnOptions)());
-            cmd.on('error', (err) => {
-                reject(err);
-            });
-            cmd.stdout.on('data', (d) => {
-                const splitted = d.toString().trim().split('\n');
-                splitted.forEach((line) => {
-                    renderer_1.RenderInternals.Log.info({ indent: true, logLevel }, line);
-                });
-            });
-            cmd.stdout.on('end', () => {
-                resolve();
-            });
-            cmd.on('close', (code, signal) => {
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Command exited with code ${code} and signal ${signal}`));
-                }
-            });
+            cmd.on('error', reject);
+            cmd.stdout.on('data', (d) => d
+                .toString()
+                .trim()
+                .split('\n')
+                .forEach((line) => renderer_1.RenderInternals.Log.info({ indent: true, logLevel }, line)));
+            cmd.stdout.on('end', resolve);
+            cmd.on('close', (code, signal) => code === 0
+                ? resolve()
+                : reject(new Error(`Command exited with code ${code} and signal ${signal}`)));
         });
-        const timeEnd = Date.now();
-        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, renderer_1.RenderInternals.chalk.gray('╰─ '), `Done in ${timeEnd - time}ms`);
-        return Promise.resolve({});
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, renderer_1.RenderInternals.chalk.gray('╰─ '), `Done in ${Date.now() - time}ms`);
+        return {};
     }
     catch (err) {
-        const timeEnd = Date.now();
-        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, renderer_1.RenderInternals.chalk.gray('╰─ '), renderer_1.RenderInternals.chalk.red(`Errored in ${timeEnd - time}ms`));
+        renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, renderer_1.RenderInternals.chalk.gray('╰─ '), renderer_1.RenderInternals.chalk.red(`Errored in ${Date.now() - time}ms`));
         return Promise.reject(err);
     }
 };

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

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