@remotion/studio-server 4.0.537 → 4.0.539

package/dist/preview-server/hot-middleware/index.d.ts

@@ -4,6 +4,7 @@
  * and rewritten in TypeScript. This file is MIT licensed
  */
 import type { webpack } from '@remotion/bundler';
+import type { LogLevel } from '@remotion/renderer';
 import type { LiveEventsServer } from '../live-events';
 declare global {
     const __webpack_hash__: unknown;
@@ -99,4 +100,4 @@ declare global {
     };
     type ModuleId = string | number;
 }
-export declare const setupWebpackHmr: (compiler: webpack.Compiler, logLevel: "error" | "info" | "trace" | "verbose" | "warn", liveEventsServer: LiveEventsServer) => void;
+export declare const setupWebpackHmr: (compiler: webpack.Compiler, logLevel: LogLevel, liveEventsServer: LiveEventsServer) => void;

package/dist/preview-server/hot-middleware/types.d.ts

@@ -0,0 +1,2 @@
+import type { webpack } from '@remotion/bundler';
+export type WebpackStats = ReturnType<webpack.Stats['toJson']>;

package/dist/preview-server/hot-middleware/types.js

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

package/dist/preview-server/jsx-component-identity.d.ts

@@ -1,12 +1,13 @@
 import type { File, JSXOpeningElement } from '@babel/types';
+import type { JsxComponentIdentity } from 'remotion';
 export declare class JsxElementIdentityMismatchError extends Error {
     constructor();
 }
 export declare const getJsxComponentIdentity: ({ ast, jsxElement, }: {
     ast: File;
     jsxElement: JSXOpeningElement;
-}) => string | null;
+}) => JsxComponentIdentity | null;
 export declare const jsxComponentIdentitiesMatch: ({ expected, actual, }: {
-    expected: string | null;
-    actual: string | null;
+    expected: JsxComponentIdentity | null;
+    actual: JsxComponentIdentity | null;
 }) => boolean;

package/dist/preview-server/live-events.d.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { LogLevel } from '@remotion/renderer';
 import type { EventSourceEvent } from '@remotion/studio-shared';
 export type LiveEventsServer = {
     sendEventToClient: (event: EventSourceEvent) => void;
@@ -7,13 +8,13 @@ export type LiveEventsServer = {
     closeConnections: () => Promise<void>;
     addNewClientListener: (cb: () => void) => () => void;
 };
-export declare const subscribeToConfigChanges: (onChange: () => void) => () => void;
+export declare const subscribeToConfigChanges: (onChange: () => void) => (() => void);
 export declare const clearPrintPortMessageTimeout: () => void;
 export type InitialUndoRedoState = {
     undoFile: string | null;
     redoFile: string | null;
 };
-export declare const makeLiveEventsRouter: (logLevel: "error" | "info" | "trace" | "verbose" | "warn", getInitialUndoRedoState: () => InitialUndoRedoState) => LiveEventsServer;
+export declare const makeLiveEventsRouter: (logLevel: LogLevel, getInitialUndoRedoState: () => InitialUndoRedoState) => LiveEventsServer;
 export declare const waitForLiveEventsListener: () => Promise<LiveEventsServer>;
 export declare const getLiveEventsListener: () => LiveEventsServer | null;
 export declare const setLiveEventsListener: (listener: LiveEventsServer) => () => void;

package/dist/preview-server/public-folder.js

@@ -47,9 +47,18 @@ const watchPublicFolder = ({ publicDir, onUpdate, staticHash, }) => {
     }
     // Known bug: If whole public folder is deleted, this will not be called on macOS.
     // This is not severe, so a wontfix for now.
+    let updateTimeout = null;
     (0, node_fs_1.watch)(publicDir, { recursive: (0, env_supports_fs_recursive_1.envSupportsFsRecursive)() }, () => {
-        (0, exports.fetchFolder)({ publicDir, staticHash });
-        onUpdate();
+        if (updateTimeout !== null) {
+            return;
+        }
+        // Imports can emit many events, each of which would scan and broadcast the
+        // entire asset list. Keep the deadline fixed so ongoing writes still update.
+        updateTimeout = setTimeout(() => {
+            updateTimeout = null;
+            (0, exports.fetchFolder)({ publicDir, staticHash });
+            onUpdate();
+        }, 100);
     });
 };
 const getFiles = () => {

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

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

package/dist/preview-server/routes/app-icon.d.ts

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 export declare const handleAppIcon: ({ request, response, pathname, }: {
     request: IncomingMessage;
-    response: ServerResponse<IncomingMessage>;
+    response: ServerResponse;
     pathname: string;
 }) => Promise<void>;

package/dist/preview-server/routes/apply-codemod.d.ts

@@ -0,0 +1,4 @@
+import type { ApplyCodemodRequest, ApplyCodemodResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const getCodemodLogMessage: (codemod: import("@remotion/studio-shared").RecastCodemod) => string;
+export declare const applyCodemodHandler: ApiHandler<ApplyCodemodRequest, ApplyCodemodResponse>;

package/dist/preview-server/routes/apply-codemod.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodemodHandler = exports.getCodemodLogMessage = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const codemods_1 = require("@remotion/codemods");
+const renderer_1 = require("@remotion/renderer");
+const apply_codemod_to_file_1 = require("../../codemods/apply-codemod-to-file");
+const file_watcher_1 = require("../../file-watcher");
+const format_log_file_location_1 = require("../format-log-file-location");
+const project_info_1 = require("../project-info");
+const undo_stack_1 = require("../undo-stack");
+const can_update_default_props_1 = require("./can-update-default-props");
+const source_file_write_queue_1 = require("./source-file-write-queue");
+const { simpleDiff } = codemods_1.CodemodsInternals;
+const getFolderPath = (parentName, folderName) => {
+    return parentName ? `${parentName}/${folderName}` : folderName;
+};
+const getCodemodLogMessage = (codemod) => {
+    if (codemod.type === 'new-composition') {
+        const destination = codemod.folderName
+            ? ` in folder "${getFolderPath(codemod.parentName, codemod.folderName)}"`
+            : '';
+        return `Created composition "${codemod.newId}"${destination}`;
+    }
+    if (codemod.type === 'duplicate-composition') {
+        return `Duplicated composition "${codemod.idToDuplicate}" to "${codemod.newId}"`;
+    }
+    if (codemod.type === 'rename-composition') {
+        return `Renamed composition "${codemod.idToRename}" to "${codemod.newId}"`;
+    }
+    if (codemod.type === 'update-composition-metadata') {
+        return `Updated metadata of composition "${codemod.idToUpdate}"`;
+    }
+    if (codemod.type === 'delete-composition') {
+        return `Deleted composition "${codemod.idToDelete}"`;
+    }
+    if (codemod.type === 'move-composition-or-folder') {
+        const source = codemod.source.type === 'composition'
+            ? `composition "${codemod.source.compositionId}"`
+            : `folder "${getFolderPath(codemod.source.parentName, codemod.source.folderName)}"`;
+        return `Moved ${source}`;
+    }
+    if (codemod.type === 'rename-folder') {
+        const oldName = getFolderPath(codemod.parentName, codemod.folderName);
+        const newName = getFolderPath(codemod.parentName, codemod.newName);
+        return `Renamed folder "${oldName}" to "${newName}"`;
+    }
+    if (codemod.type === 'new-folder') {
+        return `Created folder "${getFolderPath(codemod.parentName, codemod.folderName)}"`;
+    }
+    if (codemod.type === 'delete-folder') {
+        return `Deleted folder "${getFolderPath(codemod.parentName, codemod.folderName)}"`;
+    }
+    if (codemod.changes.length === 1) {
+        return `Updated visual control "${codemod.changes[0].id}"`;
+    }
+    return `Updated visual controls ${codemod.changes
+        .map((change) => `"${change.id}"`)
+        .join(', ')}`;
+};
+exports.getCodemodLogMessage = getCodemodLogMessage;
+const getCodemodUndoDescription = (codemod) => {
+    if (codemod.type === 'delete-composition') {
+        return {
+            undoMessage: `↩️  Deletion of composition "${codemod.idToDelete}"`,
+            redoMessage: `↪️  Deletion of composition "${codemod.idToDelete}"`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'rename-composition') {
+        const label = `composition "${codemod.idToRename}" to "${codemod.newId}"`;
+        return {
+            undoMessage: `↩️  Rename of ${label}`,
+            redoMessage: `↪️  Rename of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'update-composition-metadata') {
+        const label = `metadata of composition "${codemod.idToUpdate}"`;
+        return {
+            undoMessage: `↩️  Update of ${label}`,
+            redoMessage: `↪️  Update of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'duplicate-composition') {
+        const label = `composition "${codemod.idToDuplicate}" to "${codemod.newId}"`;
+        return {
+            undoMessage: `↩️  Duplication of ${label}`,
+            redoMessage: `↪️  Duplication of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'move-composition-or-folder') {
+        const label = codemod.source.type === 'composition'
+            ? `composition "${codemod.source.compositionId}"`
+            : `folder "${getFolderPath(codemod.source.parentName, codemod.source.folderName)}"`;
+        return {
+            undoMessage: `↩️  Move of ${label}`,
+            redoMessage: `↪️  Move of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'new-composition') {
+        return {
+            undoMessage: `↩️  Creation of composition "${codemod.newId}"`,
+            redoMessage: `↪️  Creation of composition "${codemod.newId}"`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'delete-folder') {
+        const label = `folder "${getFolderPath(codemod.parentName, codemod.folderName)}"`;
+        return {
+            undoMessage: `↩️  Deletion of ${label}`,
+            redoMessage: `↪️  Deletion of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'new-folder') {
+        const label = `folder "${getFolderPath(codemod.parentName, codemod.folderName)}"`;
+        return {
+            undoMessage: `↩️  Creation of ${label}`,
+            redoMessage: `↪️  Creation of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    if (codemod.type === 'rename-folder') {
+        const oldName = getFolderPath(codemod.parentName, codemod.folderName);
+        const newName = getFolderPath(codemod.parentName, codemod.newName);
+        const label = `folder "${oldName}" to "${newName}"`;
+        return {
+            undoMessage: `↩️  Rename of ${label}`,
+            redoMessage: `↪️  Rename of ${label}`,
+            entryType: codemod.type,
+        };
+    }
+    return {
+        undoMessage: '↩️  Visual control change',
+        redoMessage: '↪️  Visual control change',
+        entryType: 'visual-control',
+    };
+};
+const applyCodemodHandler = ({ input: { codemod, dryRun, symbolicatedStack, undoRedoNavigation }, logLevel, remotionRoot, entryPoint, }) => {
+    return (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
+        var _a, _b;
+        var _c, _d, _e;
+        try {
+            const logLine = (_c = symbolicatedStack === null || symbolicatedStack === void 0 ? void 0 : symbolicatedStack.originalLineNumber) !== null && _c !== void 0 ? _c : 1;
+            const filePath = symbolicatedStack
+                ? (0, apply_codemod_to_file_1.resolveFilePathFromSymbolicatedStack)(remotionRoot, symbolicatedStack)
+                : (await (0, project_info_1.getProjectInfo)(remotionRoot, entryPoint)).rootFile;
+            if (!filePath) {
+                throw new Error('Cannot find file for composition in project');
+            }
+            (0, can_update_default_props_1.checkIfTypeScriptFile)(filePath);
+            const newCompositionComponentFilePath = codemod.type === 'new-composition'
+                ? node_path_1.default.join(node_path_1.default.dirname(filePath), `${codemod.componentName}.tsx`)
+                : null;
+            if (codemod.type === 'new-composition' &&
+                newCompositionComponentFilePath &&
+                (0, node_fs_1.existsSync)(newCompositionComponentFilePath)) {
+                throw new Error(`Cannot create ${node_path_1.default.relative(remotionRoot, newCompositionComponentFilePath)} because it already exists`);
+            }
+            const input = (0, node_fs_1.readFileSync)(filePath, 'utf-8');
+            const result = await (0, apply_codemod_to_file_1.applyCodemodToFile)({
+                filePath,
+                codeMod: codemod,
+            });
+            const formatted = (_d = (_a = result.changes.find((change) => change.filePath === filePath)) === null || _a === void 0 ? void 0 : _a.nextContents) !== null && _d !== void 0 ? _d : input;
+            const diff = simpleDiff({
+                oldLines: input.split('\n'),
+                newLines: formatted.split('\n'),
+            });
+            if (!dryRun) {
+                if ((0, node_fs_1.readFileSync)(filePath, 'utf-8') !== input) {
+                    throw new Error(`Source changed before applying codemod: ${filePath}`);
+                }
+                for (const change of result.changes) {
+                    const currentContents = (0, node_fs_1.existsSync)(change.filePath)
+                        ? (0, node_fs_1.readFileSync)(change.filePath, 'utf-8')
+                        : null;
+                    if (currentContents !== change.previousContents) {
+                        throw new Error(`Source changed before applying codemod: ${change.filePath}`);
+                    }
+                }
+                const { entryType, undoMessage, redoMessage } = getCodemodUndoDescription(codemod);
+                const snapshots = [
+                    {
+                        filePath,
+                        oldContents: input,
+                        newContents: null,
+                        logLine,
+                        nodePathRemappings: null,
+                    },
+                ];
+                let componentFilePath = null;
+                let componentFileContents = null;
+                if (codemod.type === 'new-composition') {
+                    componentFilePath = newCompositionComponentFilePath;
+                    if (componentFilePath === null) {
+                        throw new Error('Could not determine the new component file path');
+                    }
+                    componentFileContents = (_e = (_b = result.changes.find((change) => change.filePath === componentFilePath)) === null || _b === void 0 ? void 0 : _b.nextContents) !== null && _e !== void 0 ? _e : null;
+                    if (componentFileContents === null) {
+                        throw new Error('Could not create the composition component');
+                    }
+                    snapshots.push({
+                        filePath: componentFilePath,
+                        oldContents: null,
+                        newContents: componentFileContents,
+                        logLine: 1,
+                        nodePathRemappings: null,
+                    });
+                }
+                (0, undo_stack_1.pushTransactionToUndoStack)({
+                    snapshots,
+                    logLevel,
+                    remotionRoot,
+                    description: {
+                        undoMessage,
+                        redoMessage,
+                    },
+                    entryType,
+                    suppressHmrOnFileRestore: false,
+                    undoRedoNavigation,
+                });
+                (0, undo_stack_1.suppressUndoStackInvalidation)(filePath);
+                if (componentFilePath) {
+                    (0, undo_stack_1.suppressUndoStackInvalidation)(componentFilePath);
+                }
+                (0, file_watcher_1.writeFileAndNotifyFileWatchers)({
+                    file: filePath,
+                    content: formatted,
+                    originatorClientId: undefined,
+                    metadata: null,
+                });
+                if (componentFilePath && componentFileContents !== null) {
+                    (0, file_watcher_1.writeFileAndNotifyFileWatchers)({
+                        file: componentFilePath,
+                        content: componentFileContents,
+                        originatorClientId: undefined,
+                        metadata: null,
+                    });
+                }
+                const logMessage = (0, exports.getCodemodLogMessage)(codemod);
+                const editMessage = `${(0, source_file_write_queue_1.getCodemodTimingPrefix)(logLevel)}${renderer_1.RenderInternals.chalk.blueBright((0, format_log_file_location_1.formatLogFileLocation)({
+                    remotionRoot,
+                    absolutePath: filePath,
+                    line: logLine,
+                }))} ${logMessage}`;
+                renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, editMessage);
+                (0, undo_stack_1.printUndoHint)(logLevel);
+            }
+            return {
+                success: true,
+                diff,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                reason: err.message,
+                stack: err.stack,
+            };
+        }
+    });
+};
+exports.applyCodemodHandler = applyCodemodHandler;

package/dist/preview-server/routes/apply-visual-control-change.js

@@ -28,10 +28,7 @@ const applyVisualControlHandler = ({ input: { fileName, changes }, remotionRoot,
             changes,
         });
         const output = (_c = (_a = result.changes[0]) === null || _a === void 0 ? void 0 : _a.nextContents) !== null && _c !== void 0 ? _c : fileContents;
-        const logLine = (_d = (_b = result.updatedControls.findLast((control) => {
-            var _a;
-            return control.id === ((_a = changes[0]) === null || _a === void 0 ? void 0 : _a.id);
-        })) === null || _b === void 0 ? void 0 : _b.line) !== null && _d !== void 0 ? _d : 1;
+        const logLine = (_d = (_b = result.updatedControls.findLast((control) => { var _a; return control.id === ((_a = changes[0]) === null || _a === void 0 ? void 0 : _a.id); })) === null || _b === void 0 ? void 0 : _b.line) !== null && _d !== void 0 ? _d : 1;
         if (result.updatedControls.length === 0) {
             throw new Error('No changes were made to the file');
         }

package/dist/preview-server/routes/batch-update-keyframe-settings.d.ts

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

package/dist/preview-server/routes/can-update-default-props.d.ts

@@ -1,5 +1,6 @@
+import { CodemodsInternals } from '@remotion/codemods';
 import type { CanUpdateDefaultPropsResponse, SymbolicatedStackFrame } from '@remotion/studio-shared';
-export declare const computeCanUpdateDefaultPropsFromContent: (content: string, compositionId: string) => CanUpdateDefaultPropsResponse;
+export declare const { computeCanUpdateDefaultPropsFromContent, }: typeof CodemodsInternals;
 export declare const checkIfTypeScriptFile: (file: string) => void;
 export declare const getDefaultPropsFile: ({ symbolicatedStack, remotionRoot, entryPoint, }: {
     symbolicatedStack: SymbolicatedStackFrame | null;

package/dist/preview-server/routes/can-update-effect-props.d.ts

@@ -1,4 +1,5 @@
 import type { File, JSXOpeningElement } from '@babel/types';
+import { CodemodsInternals } from '@remotion/codemods';
 import type { CanUpdateEffectPropsResponse, SequenceNodePath, InteractivitySchema } from 'remotion';
 import { type VideoConfigIdentifierValues } from '../../helpers/video-config-values';
 export declare const computeEffectPropStatus: ({ ast, jsx, effectIndex, keys, videoConfigValues, }: {
@@ -8,12 +9,7 @@ export declare const computeEffectPropStatus: ({ ast, jsx, effectIndex, keys, vi
     keys: string[];
     videoConfigValues: VideoConfigIdentifierValues;
 }) => CanUpdateEffectPropsResponse;
-export declare const computeEffectPropsStatusesFromContent: ({ fileContents, sequenceNodePath, effects, keysFor, }: {
-    fileContents: string;
-    sequenceNodePath: SequenceNodePath;
-    effects: InteractivitySchema[];
-    keysFor: (effect: InteractivitySchema) => string[];
-}) => CanUpdateEffectPropsResponse<import("remotion").SourceNumericValue>[];
+export declare const { computeEffectPropsStatusesFromContent }: typeof CodemodsInternals;
 export declare const computeEffectPropsStatusesFromFile: ({ fileName, sequenceNodePath, effects, keysFor, remotionRoot, }: {
     fileName: string;
     sequenceNodePath: SequenceNodePath;

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

@@ -1,6 +1,7 @@
 import type { Expression, File, JSXElement, JSXOpeningElement } from '@babel/types';
 import type { SubscribeToSequencePropsResponse } from '@remotion/studio-shared';
-import type { CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, SequenceNodePath } from 'remotion';
+import * as recast from 'recast';
+import type { CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, JsxComponentIdentity, LogLevel, SequenceNodePath } from 'remotion';
 import { type VideoConfigIdentifierValues } from '../../helpers/video-config-values';
 type CanUpdatePropStatus = CanUpdateSequencePropStatus;
 type StaticValueOptions = {
@@ -10,7 +11,7 @@ export declare const isStaticValue: (node: Expression, options?: StaticValueOpti
 export declare const extractStaticValue: (node: Expression, options?: StaticValueOptions) => unknown;
 export declare const getComputedStatus: (node: Expression, ast: File, videoConfigValues: VideoConfigIdentifierValues) => CanUpdatePropStatus;
 export declare const getNodePathForRecastPath: (recastPath: any, ast: File) => SequenceNodePath;
-export declare const findJsxElementPathAtNodePath: (ast: File, nodePath: SequenceNodePath) => import("ast-types/lib/node-path").NodePath<N, V> | null;
+export declare const findJsxElementPathAtNodePath: (ast: File, nodePath: SequenceNodePath) => recast.types.NodePath<any, any> | null;
 export declare const findJsxElementAtNodePath: (ast: File, nodePath: SequenceNodePath) => JSXOpeningElement | null;
 export declare const findJsxElementNodeAtNodePath: (ast: File, nodePath: SequenceNodePath) => JSXElement | null;
 export type StaticJsxTextContent = {
@@ -24,7 +25,7 @@ export declare const getStaticJsxChildrenAttribute: (jsxElement: JSXOpeningEleme
 export declare const hasJsxChildrenAttribute: (jsxElement: JSXOpeningElement) => boolean;
 export declare const getStaticJsxTextContent: (jsxElement: JSXElement) => StaticJsxTextContent | null;
 export declare const findNodePathForJsxElement: (ast: File, target: JSXOpeningElement) => SequenceNodePath | null;
-export declare const lineColumnToNodePath: (ast: File, targetLine: number, targetColumn?: number | undefined, fileContents?: string | undefined) => SequenceNodePath | null;
+export declare const lineColumnToNodePath: (ast: File, targetLine: number, targetColumn?: number, fileContents?: string) => SequenceNodePath | null;
 export declare const lineColumnsToNodePaths: ({ ast, targets, fileContents, }: {
     ast: File;
     targets: {
@@ -33,40 +34,43 @@ export declare const lineColumnsToNodePaths: ({ ast, targets, fileContents, }: {
     }[];
     fileContents: string;
 }) => (SequenceNodePath | null)[];
-export declare const resolveSequencePropsNodePathsFromFilename: ({ fileName, targets, remotionRoot, }: {
+export declare const resolveSequencePropsNodePathsFromFilename: ({ fileName, targets, remotionRoot, fileContentsCache, }: {
     fileName: string;
     targets: {
         line: number;
         column: number;
     }[];
     remotionRoot: string;
+    fileContentsCache: Map<string, string> | null;
 }) => (SequenceNodePath | null)[];
 export declare const computeSequencePropsStatusFromContent: ({ fileContents, nodePath, componentIdentity, keys, assetKeys, effects, }: {
     fileContents: string;
     nodePath: SequenceNodePath;
-    componentIdentity: string | null;
+    componentIdentity: JsxComponentIdentity | null;
     keys: string[];
-    assetKeys?: string[] | undefined;
+    assetKeys?: string[];
     effects: string[][];
 }) => CanUpdateSequencePropsResponseTrue;
-export declare const computeSequencePropsStatus: ({ fileName, nodePath, componentIdentity, keys, assetKeys, effects, remotionRoot, }: {
+export declare const computeSequencePropsStatus: ({ fileName, nodePath, componentIdentity, keys, assetKeys, effects, remotionRoot, fileContentsCache, }: {
     fileName: string;
     nodePath: SequenceNodePath;
-    componentIdentity: string | null;
+    componentIdentity: JsxComponentIdentity | null;
     keys: string[];
-    assetKeys?: string[] | undefined;
+    assetKeys?: string[];
     effects: string[][];
     remotionRoot: string;
+    fileContentsCache: Map<string, string> | null;
 }) => CanUpdateSequencePropsResponseTrue;
-export declare const computeSequencePropsStatusFromFilenameByLocation: ({ fileName, line, column, componentIdentity, keys, assetKeys, effects, remotionRoot, logLevel, }: {
+export declare const computeSequencePropsStatusFromFilenameByLocation: ({ fileName, line, column, componentIdentity, keys, assetKeys, effects, remotionRoot, logLevel, fileContentsCache, }: {
     fileName: string;
     line: number;
     column: number;
-    componentIdentity: string | null;
+    componentIdentity: JsxComponentIdentity | null;
     keys: string[];
-    assetKeys?: string[] | undefined;
+    assetKeys?: string[];
     effects: string[][];
     remotionRoot: string;
-    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+    logLevel: LogLevel;
+    fileContentsCache: Map<string, string> | null;
 }) => SubscribeToSequencePropsResponse;
 export {};