@remotion/studio-server 4.0.537 → 4.0.539

package/dist/preview-server/routes/split-jsx-sequence.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitJsxSequenceHandler = 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 splitJsxSequenceHandler = ({ input: { sequences }, remotionRoot, logLevel }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
+    var _a;
+    try {
+        if (sequences.length === 0) {
+            throw new Error('No JSX sequences were specified for splitting');
+        }
+        renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[split-jsx-sequence] Received request to split ${sequences.length} JSX sequence${sequences.length === 1 ? '' : 's'}`);
+        const sequencesByFileName = new Map();
+        for (const sequence of sequences) {
+            const fileSequences = (_a = sequencesByFileName.get(sequence.fileName)) !== null && _a !== void 0 ? _a : [];
+            fileSequences.push(sequence);
+            sequencesByFileName.set(sequence.fileName, fileSequences);
+        }
+        const updates = await Promise.all([...sequencesByFileName].map(async ([fileName, fileSequences]) => {
+            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.splitSequences)({
+                project: {
+                    files: { [absolutePath]: fileContents },
+                    rootDir: remotionRoot,
+                },
+                splits: fileSequences.map(({ nodePath, sequenceKeys, splitFrame }) => ({
+                    node: { filePath: absolutePath, nodePath },
+                    sequenceKeys,
+                    frame: splitFrame,
+                })),
+            });
+            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,
+                fileContents,
+                fileRelativeToRoot,
+                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 splitDescription = sequences.length === 1
+            ? updates[0].nodeLabels[0]
+            : `${sequences.length} JSX sequences`;
+        (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: `↩️  Split of ${splitDescription}`,
+                redoMessage: `↪️  Split of ${splitDescription}`,
+            },
+            entryType: 'split-jsx-sequence',
+            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 sequences`;
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${(0, source_file_write_queue_1.getCodemodTimingPrefix)(logLevel)}${renderer_1.RenderInternals.chalk.blueBright(`${locationLabel}`)} Split ${fileDescription}`);
+            renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `[split-jsx-sequence] 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.splitJsxSequenceHandler = splitJsxSequenceHandler;

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

@@ -1,51 +1,72 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subscribeToSequenceProps = void 0;
+const node_path_1 = __importDefault(require("node:path"));
 const sequence_props_watchers_1 = require("../sequence-props-watchers");
 const can_update_sequence_props_1 = require("./can-update-sequence-props");
 const subscribeToSequenceProps = ({ input, remotionRoot, logLevel }) => {
     var _a;
-    const unresolvedByFile = new Map();
+    // Source contents are shared only within this synchronous subscription batch.
+    const fileContentsCache = new Map();
+    const requestsByFile = new Map();
     for (const [index, request] of input.requests.entries()) {
-        if (request.nodePath !== null) {
-            continue;
-        }
-        const unresolved = (_a = unresolvedByFile.get(request.fileName)) !== null && _a !== void 0 ? _a : [];
-        unresolved.push({ index, line: request.line, column: request.column });
-        unresolvedByFile.set(request.fileName, unresolved);
+        const absolutePath = node_path_1.default.resolve(remotionRoot, request.fileName);
+        const indexes = (_a = requestsByFile.get(absolutePath)) !== null && _a !== void 0 ? _a : [];
+        indexes.push(index);
+        requestsByFile.set(absolutePath, indexes);
     }
-    const resolvedNodePaths = new Map();
-    for (const [fileName, unresolved] of unresolvedByFile) {
-        try {
-            const nodePaths = (0, can_update_sequence_props_1.resolveSequencePropsNodePathsFromFilename)({
-                fileName,
-                targets: unresolved,
-                remotionRoot,
-            });
-            for (const [index, nodePath] of nodePaths.entries()) {
-                if (nodePath) {
-                    resolvedNodePaths.set(unresolved[index].index, nodePath);
+    const results = [];
+    // Finish each file before moving on so large batches do not evict and
+    // repeatedly parse the same source snapshot from the bounded AST cache.
+    for (const indexes of requestsByFile.values()) {
+        const unresolved = indexes
+            .filter((index) => input.requests[index].nodePath === null)
+            .map((index) => ({
+            index,
+            line: input.requests[index].line,
+            column: input.requests[index].column,
+        }));
+        const resolvedNodePaths = new Map();
+        if (unresolved.length > 0) {
+            try {
+                const nodePaths = (0, can_update_sequence_props_1.resolveSequencePropsNodePathsFromFilename)({
+                    fileName: input.requests[indexes[0]].fileName,
+                    targets: unresolved,
+                    remotionRoot,
+                    fileContentsCache,
+                });
+                for (const [index, nodePath] of nodePaths.entries()) {
+                    if (nodePath) {
+                        resolvedNodePaths.set(unresolved[index].index, nodePath);
+                    }
                 }
             }
+            catch (_b) {
+                // Let each subscription produce its usual not-found response.
+            }
         }
-        catch (_b) {
-            // Let each subscription produce its usual not-found response.
+        for (const index of indexes) {
+            const { fileName, line, column, nodePath, componentIdentity, keys, assetKeys, effects, clientId, } = input.requests[index];
+            results[index] = (0, sequence_props_watchers_1.subscribeToSequencePropsWatchers)({
+                fileName,
+                line,
+                column,
+                nodePath,
+                resolvedNodePath: resolvedNodePaths.get(index),
+                componentIdentity,
+                keys,
+                assetKeys,
+                effects,
+                remotionRoot,
+                clientId,
+                logLevel,
+                fileContentsCache,
+            });
         }
     }
-    const results = input.requests.map(({ fileName, line, column, nodePath, componentIdentity, keys, assetKeys, effects, clientId, }, index) => (0, sequence_props_watchers_1.subscribeToSequencePropsWatchers)({
-        fileName,
-        line,
-        column,
-        nodePath,
-        resolvedNodePath: resolvedNodePaths.get(index),
-        componentIdentity,
-        keys,
-        assetKeys,
-        effects,
-        remotionRoot,
-        clientId,
-        logLevel,
-    }));
     return Promise.resolve({ results });
 };
 exports.subscribeToSequenceProps = subscribeToSequenceProps;

package/dist/preview-server/routes/update-public-license.d.ts

@@ -0,0 +1,11 @@
+import type { UpdatePublicLicenseRequest, UpdatePublicLicenseResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const updatePublicLicenseInConfig: ({ configContents, publicLicenseKey, }: {
+    configContents: string;
+    publicLicenseKey: string;
+}) => string;
+export declare const setPublicLicenseKeyInConfigFile: ({ configFile, publicLicenseKey, }: {
+    readonly configFile: string;
+    readonly publicLicenseKey: string;
+}) => void;
+export declare const updatePublicLicenseHandler: ApiHandler<UpdatePublicLicenseRequest, UpdatePublicLicenseResponse>;

package/dist/preview-server/routes/update-public-license.js

@@ -0,0 +1,97 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePublicLicenseHandler = exports.setPublicLicenseKeyInConfigFile = exports.updatePublicLicenseInConfig = void 0;
+const node_fs_1 = require("node:fs");
+const recast = __importStar(require("recast"));
+const parse_ast_1 = require("../../codemods/parse-ast");
+const file_watcher_1 = require("../../file-watcher");
+const updatePublicLicenseInConfig = ({ configContents, publicLicenseKey, }) => {
+    const ast = (0, parse_ast_1.parseAst)(configContents);
+    recast.types.visit(ast.program, {
+        visitExpressionStatement(path) {
+            const { expression } = path.node;
+            if (expression.type === 'CallExpression' &&
+                expression.callee.type === 'MemberExpression' &&
+                !expression.callee.computed &&
+                expression.callee.object.type === 'Identifier' &&
+                expression.callee.object.name === 'Config' &&
+                expression.callee.property.type === 'Identifier' &&
+                expression.callee.property.name === 'setPublicLicenseKey') {
+                path.prune();
+                return false;
+            }
+            this.traverse(path);
+        },
+    });
+    const configWithoutExistingCalls = recast.print(ast, {
+        lineTerminator: '\n',
+    }).code;
+    const separator = configWithoutExistingCalls.endsWith('\n') ? '' : '\n';
+    const escapedPublicLicenseKey = publicLicenseKey
+        .replaceAll('\\', '\\\\')
+        .replaceAll("'", "\\'")
+        .replaceAll('\r', '\\r')
+        .replaceAll('\n', '\\n')
+        .replaceAll('\u2028', '\\u2028')
+        .replaceAll('\u2029', '\\u2029');
+    return `${configWithoutExistingCalls}${separator}Config.setPublicLicenseKey('${escapedPublicLicenseKey}');\n`;
+};
+exports.updatePublicLicenseInConfig = updatePublicLicenseInConfig;
+const setPublicLicenseKeyInConfigFile = ({ configFile, publicLicenseKey, }) => {
+    const configContents = (0, node_fs_1.readFileSync)(configFile, 'utf8');
+    (0, file_watcher_1.writeFileAndNotifyFileWatchers)(configFile, (0, exports.updatePublicLicenseInConfig)({ configContents, publicLicenseKey }), undefined);
+};
+exports.setPublicLicenseKeyInConfigFile = setPublicLicenseKeyInConfigFile;
+const updatePublicLicenseHandler = ({ input, configFile }) => {
+    if (configFile === null || configFile === undefined) {
+        return Promise.resolve({
+            success: false,
+            reason: 'No Remotion config file was loaded.',
+        });
+    }
+    if (input.publicLicenseKey.length === 0) {
+        return Promise.resolve({
+            success: false,
+            reason: 'The public license key must not be empty.',
+        });
+    }
+    (0, exports.setPublicLicenseKeyInConfigFile)({
+        configFile,
+        publicLicenseKey: input.publicLicenseKey,
+    });
+    return Promise.resolve({ success: true });
+};
+exports.updatePublicLicenseHandler = updatePublicLicenseHandler;

package/dist/preview-server/routes/wrap-jsx-node.d.ts

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

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapJsxNodeHandler = 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 wrapJsxNodeHandler = ({ input: { fileName, nodePath, wrapper, width, height }, remotionRoot, logLevel, }) => {
+    return (0, source_file_write_queue_1.withSourceFileWriteQueue)(() => {
+        var _a;
+        try {
+            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 eligibility = (0, codemods_1.canWrapJsxNode)({ input: fileContents, nodePath });
+            if (wrapper === null) {
+                return Promise.resolve({
+                    success: true,
+                    ...eligibility,
+                    nodePathMutation: null,
+                });
+            }
+            if (!eligibility.canWrap ||
+                (wrapper === 'HtmlInCanvas' && !eligibility.canWrapHtmlInCanvas)) {
+                throw new Error('This JSX element cannot be wrapped');
+            }
+            const result = (0, codemods_1.wrapJsxNode)({
+                project: { files: { [absolutePath]: fileContents }, rootDir: remotionRoot },
+                node: { filePath: absolutePath, nodePath },
+                wrapper,
+                width: width !== null && width !== void 0 ? width : 0,
+                height: height !== null && height !== void 0 ? height : 0,
+            });
+            const change = result.changes.find(({ filePath }) => filePath === absolutePath);
+            if ((change === null || change === void 0 ? void 0 : change.previousContents) !== fileContents ||
+                change.nextContents === null) {
+                throw new Error('Could not wrap JSX node');
+            }
+            const output = change.nextContents;
+            const remappings = result.nodePathRemappings.map(({ oldNodePath, newNodePath }) => ({ oldNodePath, newNodePath }));
+            const nodePathMutation = (0, sequence_node_path_mutation_1.broadcastSequenceNodePathMutation)([{ absolutePath, remappings }], null);
+            const line = result.logLine;
+            (0, undo_stack_1.pushTransactionToUndoStack)({
+                snapshots: [
+                    {
+                        filePath: absolutePath,
+                        oldContents: fileContents,
+                        newContents: null,
+                        logLine: line,
+                        nodePathRemappings: remappings,
+                    },
+                ],
+                logLevel,
+                remotionRoot,
+                description: {
+                    undoMessage: `↩️  Wrapping in ${wrapper}`,
+                    redoMessage: `↪️  Wrapping in ${wrapper}`,
+                },
+                entryType: 'wrap-jsx-node',
+                suppressHmrOnFileRestore: false,
+                undoRedoNavigation: null,
+            });
+            (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,
+            });
+            renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, `${(0, source_file_write_queue_1.getCodemodTimingPrefix)(logLevel)}${renderer_1.RenderInternals.chalk.blueBright(locationLabel)} Wrapped JSX in <${wrapper}>`);
+            renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, `[wrap-jsx-node] Wrote ${fileRelativeToRoot}`);
+            (0, undo_stack_1.printUndoHint)(logLevel);
+            return Promise.resolve({ success: true, ...eligibility, nodePathMutation });
+        }
+        catch (err) {
+            return Promise.resolve({
+                success: false,
+                reason: err.message,
+                stack: (_a = err.stack) !== null && _a !== void 0 ? _a : '',
+            });
+        }
+    });
+};
+exports.wrapJsxNodeHandler = wrapJsxNodeHandler;

package/dist/preview-server/sequence-node-path-mutation.d.ts

@@ -1,9 +1,5 @@
 import type { SequenceNodePathMutation, SequenceNodePathRemapping } from '@remotion/studio-shared';
-export declare const broadcastSequenceNodePathMutation: (files: {
+export declare const broadcastSequenceNodePathMutation: (files: Array<{
     absolutePath: string;
     remappings: SequenceNodePathRemapping[];
-}[], timelineSelection: {
-    compositionId: string;
-    absolutePath: string;
-    nodePath: import("remotion").SequenceNodePath;
-} | null) => SequenceNodePathMutation;
+}>, timelineSelection: SequenceNodePathMutation['timelineSelection']) => SequenceNodePathMutation;

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

@@ -1,18 +1,20 @@
+import type { LogLevel } from '@remotion/renderer';
 import { type SubscribeToSequencePropsResponse } from '@remotion/studio-shared';
-import type { SequenceNodePath } from 'remotion';
-export declare const subscribeToSequencePropsWatchers: ({ fileName, line, column, nodePath: preferredNodePath, resolvedNodePath, componentIdentity, keys, assetKeys, effects, remotionRoot, clientId, logLevel, }: {
+import type { JsxComponentIdentity, SequenceNodePath } from 'remotion';
+export declare const subscribeToSequencePropsWatchers: ({ fileName, line, column, nodePath: preferredNodePath, resolvedNodePath, componentIdentity, keys, assetKeys, effects, remotionRoot, clientId, logLevel, fileContentsCache, }: {
     fileName: string;
     line: number;
     column: number;
     nodePath: SequenceNodePath | null;
-    resolvedNodePath?: SequenceNodePath | null | undefined;
-    componentIdentity: string | null;
+    resolvedNodePath?: SequenceNodePath | null;
+    componentIdentity: JsxComponentIdentity | null;
     keys: string[];
     assetKeys: string[];
     effects: string[][];
     remotionRoot: string;
     clientId: string;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
+    fileContentsCache: Map<string, string> | null;
 }) => SubscribeToSequencePropsResponse;
 export declare const unsubscribeFromSequencePropsWatchers: ({ fileName, nodePath, remotionRoot, clientId, sequenceKeys, assetKeys, effectKeys, }: {
     fileName: string;

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

@@ -15,7 +15,7 @@ const node_path_cache_1 = require("./node-path-cache");
 const can_update_sequence_props_1 = require("./routes/can-update-sequence-props");
 const sequencePropsWatchers = {};
 const getWatcherKey = (nodePath, assetKeys) => `${(0, studio_shared_1.stringifySequenceSubscriptionKey)(nodePath)}:${assetKeys.join('\0')}`;
-const getSequencePropsStatus = ({ fileName, line, column, preferredNodePath, resolvedNodePath, componentIdentity, keys, assetKeys, effects, remotionRoot, logLevel, }) => {
+const getSequencePropsStatus = ({ fileName, line, column, preferredNodePath, resolvedNodePath, componentIdentity, keys, assetKeys, effects, remotionRoot, logLevel, fileContentsCache, }) => {
     if (preferredNodePath) {
         try {
             const fromNodePath = (0, can_update_sequence_props_1.computeSequencePropsStatus)({
@@ -26,6 +26,7 @@ const getSequencePropsStatus = ({ fileName, line, column, preferredNodePath, res
                 assetKeys,
                 effects,
                 remotionRoot,
+                fileContentsCache,
             });
             return {
                 status: fromNodePath,
@@ -59,6 +60,7 @@ const getSequencePropsStatus = ({ fileName, line, column, preferredNodePath, res
                     assetKeys,
                     effects,
                     remotionRoot,
+                    fileContentsCache,
                 });
             }
             catch (error) {
@@ -94,6 +96,7 @@ const getSequencePropsStatus = ({ fileName, line, column, preferredNodePath, res
                     assetKeys,
                     effects,
                     remotionRoot,
+                    fileContentsCache,
                 }),
                 nodePath: {
                     absolutePath: node_path_1.default.resolve(remotionRoot, fileName),
@@ -122,10 +125,11 @@ const getSequencePropsStatus = ({ fileName, line, column, preferredNodePath, res
         effects,
         remotionRoot,
         logLevel,
+        fileContentsCache,
     });
     return status;
 };
-const subscribeToSequencePropsWatchers = ({ fileName, line, column, nodePath: preferredNodePath, resolvedNodePath = null, componentIdentity, keys, assetKeys, effects, remotionRoot, clientId, logLevel, }) => {
+const subscribeToSequencePropsWatchers = ({ fileName, line, column, nodePath: preferredNodePath, resolvedNodePath = null, componentIdentity, keys, assetKeys, effects, remotionRoot, clientId, logLevel, fileContentsCache, }) => {
     var _a;
     const initialResult = getSequencePropsStatus({
         fileName,
@@ -139,6 +143,7 @@ const subscribeToSequencePropsWatchers = ({ fileName, line, column, nodePath: pr
         effects,
         remotionRoot,
         logLevel,
+        fileContentsCache,
     });
     if (!initialResult.success) {
         return initialResult;

package/dist/preview-server/serve-static.d.ts

@@ -10,7 +10,7 @@ export declare const serveStatic: ({ root, path, req, res, allowOutsidePublicFol
     root: string;
     path: string;
     req: IncomingMessage;
-    res: ServerResponse<IncomingMessage>;
+    res: ServerResponse;
     allowOutsidePublicFolder: boolean;
     allowRemotionConvertCors: boolean;
 }) => Promise<void>;

package/dist/preview-server/serve-static.js

@@ -82,12 +82,22 @@ const serveStatic = async function ({ root, path, req, res, allowOutsidePublicFo
         res.end();
         return;
     }
+    if (res.destroyed) {
+        return;
+    }
     const hasRange = req.headers.range && lstat.size;
     if (!hasRange) {
-        const readStream = (0, node_fs_1.createReadStream)(path);
         res.setHeader('content-type', renderer_1.RenderInternals.mimeLookup(path) || 'application/octet-stream');
         res.setHeader('content-length', lstat.size);
         res.writeHead(200);
+        if (req.method === 'HEAD') {
+            res.end();
+            return;
+        }
+        const readStream = (0, node_fs_1.createReadStream)(path);
+        res.once('close', () => {
+            readStream.destroy();
+        });
         readStream.pipe(res);
         return;
     }
@@ -101,10 +111,17 @@ const serveStatic = async function ({ root, path, req, res, allowOutsidePublicFo
         }));
         res.setHeader('content-length', end - start + 1);
         res.writeHead(206);
+        if (req.method === 'HEAD') {
+            res.end();
+            return;
+        }
         const readStream = (0, node_fs_1.createReadStream)(path, {
             start,
             end,
         });
+        res.once('close', () => {
+            readStream.destroy();
+        });
         readStream.pipe(res);
         return;
     }

package/dist/preview-server/start-server.d.ts

@@ -1,5 +1,5 @@
 import type { BundlerOverrideFn, RspackOverrideFn, WebpackOverrideFn } from '@remotion/bundler';
-import type { DefaultEditor } from '@remotion/renderer';
+import type { DefaultCodingAgent, DefaultEditor, LogLevel } from '@remotion/renderer';
 import type { GitSource, RenderDefaults, RenderJob, StudioRuntimeConfig } from '@remotion/studio-shared';
 import type { QueueMethods } from './api-types';
 import type { LiveEventsServer } from './live-events';
@@ -28,7 +28,7 @@ export declare const startServer: (options: {
     staticHashPrefix: string;
     outputHash: string;
     outputHashPrefix: string;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
     getRenderQueue: () => RenderJob[];
     getRenderDefaults: () => RenderDefaults;
     getNumberOfAudioTags: () => number;
@@ -43,7 +43,7 @@ export declare const startServer: (options: {
     forceNew: boolean;
     rspack: boolean;
     getStudioRuntimeConfig: () => StudioRuntimeConfig;
-    getDefaultCodingAgent: () => "claude-code" | "codex" | "copilot" | "cursor" | null;
+    getDefaultCodingAgent: () => DefaultCodingAgent | null;
     getDefaultEditor: () => DefaultEditor | null;
     configFile: string | null;
 }) => Promise<StartServerResult>;

package/dist/preview-server/studio-protocol/handle-discovery.d.ts

@@ -7,5 +7,5 @@ export declare const handleStudioProtocolDiscovery: ({ gitSource, liveEventsServ
     readonly liveEventsServer: LiveEventsServer;
     readonly remotionRoot: string;
     readonly request: IncomingMessage;
-    readonly response: ServerResponse<IncomingMessage>;
+    readonly response: ServerResponse;
 }) => Promise<void>;

package/dist/preview-server/studio-protocol/handle-element-library.d.ts

@@ -6,6 +6,6 @@ export declare const handleStudioProtocolElementLibrary: ({ configFile, focusStu
     readonly focusStudioTab: FocusStudioTab;
     readonly liveEventsServer: LiveEventsServer;
     readonly request: IncomingMessage;
-    readonly response: ServerResponse<IncomingMessage>;
+    readonly response: ServerResponse;
 }) => Promise<void>;
 export {};

package/dist/preview-server/studio-protocol/handle-install.d.ts

@@ -5,6 +5,6 @@ export declare const handleStudioProtocolInstall: ({ focusStudioTab, liveEventsS
     readonly focusStudioTab: FocusStudioTab;
     readonly liveEventsServer: LiveEventsServer;
     readonly request: IncomingMessage;
-    readonly response: ServerResponse<IncomingMessage>;
+    readonly response: ServerResponse;
 }) => Promise<void>;
 export {};

package/dist/preview-server/studio-protocol/handle-license-key.d.ts

@@ -6,6 +6,6 @@ export declare const handleStudioProtocolLicenseKey: ({ configFile, focusStudioT
     readonly focusStudioTab: FocusStudioTab;
     readonly liveEventsServer: LiveEventsServer;
     readonly request: IncomingMessage;
-    readonly response: ServerResponse<IncomingMessage>;
+    readonly response: ServerResponse;
 }) => Promise<void>;
 export {};

package/dist/preview-server/studio-protocol/origin-policy.d.ts

@@ -2,9 +2,9 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 export declare const getAllowedStudioProtocolOrigin: (request: IncomingMessage) => string | null;
 export declare const setStudioProtocolCorsHeaders: ({ request, response, }: {
     readonly request: IncomingMessage;
-    readonly response: ServerResponse<IncomingMessage>;
+    readonly response: ServerResponse;
 }) => void;
 export declare const handleStudioProtocolOptions: ({ request, response, }: {
     readonly request: IncomingMessage;
-    readonly response: ServerResponse<IncomingMessage>;
+    readonly response: ServerResponse;
 }) => Promise<void>;