@remotion/studio-server 4.0.540 → 4.0.541

package/dist/codemods/get-node-path-remappings.d.ts

@@ -1,6 +1,9 @@
-import type { File } from '@babel/types';
 import type { SequenceNodePath } from 'remotion';
 export type CapturedJsxNodePath = {
     nodePath: SequenceNodePath;
+    location: {
+        line: number;
+        column: number;
+    } | null;
 };
-export declare const captureJsxNodePaths: (ast: File) => CapturedJsxNodePath[];
+export declare const captureJsxNodePaths: (source: string) => CapturedJsxNodePath[];

package/dist/codemods/get-node-path-remappings.js

@@ -34,14 +34,20 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.captureJsxNodePaths = void 0;
+const codemods_1 = require("@remotion/codemods");
 const recast = __importStar(require("recast"));
 const can_update_sequence_props_1 = require("../preview-server/routes/can-update-sequence-props");
-const captureJsxNodePaths = (ast) => {
+const parse_ast_1 = require("./parse-ast");
+const captureJsxNodePaths = (source) => {
+    const ast = (0, parse_ast_1.parseAst)(source);
     const captured = [];
     recast.visit(ast, {
         visitJSXOpeningElement(path) {
             captured.push({
                 nodePath: (0, can_update_sequence_props_1.getNodePathForRecastPath)(path, ast),
+                location: path.node.loc
+                    ? codemods_1.CodemodsInternals.getJsxSourceLocation(source, path.node.loc.start)
+                    : null,
             });
             return this.traverse(path);
         },

package/dist/file-watcher.d.ts

@@ -23,6 +23,7 @@ export type FileChangeEvent = {
     sourceVersion: SourceFileVersion | null;
 };
 type OnChange = (event: FileChangeEvent) => void;
+export declare const subscribeToStudioSourceWrites: (listener: (file: string, contents: string) => void) => () => boolean;
 export type FileWatcherRegistry = {
     readonly sourceVersionSessionId: string;
     installFileWatcher: (options: {

package/dist/file-watcher.js

@@ -33,10 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFileAndNotifyFileWatchers = exports.installFileWatcher = exports.getFileWatcherRegistry = exports.setFileWatcherRegistry = exports.getSourceVersionSessionId = exports.createFileWatcherRegistry = void 0;
+exports.writeFileAndNotifyFileWatchers = exports.installFileWatcher = exports.getFileWatcherRegistry = exports.setFileWatcherRegistry = exports.getSourceVersionSessionId = exports.createFileWatcherRegistry = exports.subscribeToStudioSourceWrites = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = __importStar(require("node:fs"));
 const watch_ignore_next_change_1 = require("./preview-server/watch-ignore-next-change");
+const sourceWriteListeners = new Set();
+const subscribeToStudioSourceWrites = (listener) => {
+    sourceWriteListeners.add(listener);
+    return () => sourceWriteListeners.delete(listener);
+};
+exports.subscribeToStudioSourceWrites = subscribeToStudioSourceWrites;
 const getRegistryKey = (file, existenceOnly) => existenceOnly ? `${file}\0existence-only` : file;
 const createFileWatcherRegistry = () => {
     const sharedWatchers = new Map();
@@ -148,6 +154,8 @@ const createFileWatcherRegistry = () => {
         (0, watch_ignore_next_change_1.prepareBundlerForFileWrite)(file);
         (0, node_fs_1.writeFileSync)(file, content);
         const sourceVersion = nextSourceVersion();
+        for (const listener of sourceWriteListeners)
+            listener(file, content);
         const shared = sharedWatchers.get(getRegistryKey(file, false));
         if (!shared) {
             return sourceVersion;

package/dist/index.d.ts

@@ -12,7 +12,9 @@ import { getPackageManagerSpawnOptions } from './helpers/package-manager-spawn-o
 import { getConfiguredMaxTimelineTracks, getMaxTimelineTracks, resetMaxTimelineTracks, setMaxTimelineTracks } from './max-timeline-tracks';
 import { getPackageManager } from './preview-server/get-package-manager';
 import { waitForLiveEventsListener } from './preview-server/live-events';
+import { replaceWithPrerenderedVideo } from './preview-server/prerendered-scene';
 import { getEditorName } from './preview-server/routes/open-in-editor';
+import { subscribeToSequenceNodePathMutations } from './preview-server/sequence-node-path-mutation';
 import { getRemotionVersion } from './preview-server/update-available';
 import { remotionSkillNames } from './remotion-skill-names';
 import { startStudio } from './start-studio';
@@ -71,4 +73,6 @@ export declare const StudioServerInternals: {
     parseRemotionSkillVersion: typeof parseRemotionSkillVersion;
     remotionSkillNames: readonly ["remotion-best-practices", "remotion-captions", "remotion-create", "remotion-docs", "remotion-interactivity", "remotion-license", "remotion-maps", "remotion-markup", "remotion-multimedia", "remotion-render", "remotion-saas", "remotion-studio", "remotion-upgrade"];
     getEditorName: typeof getEditorName;
+    replaceWithPrerenderedVideo: typeof replaceWithPrerenderedVideo;
+    subscribeToSequenceNodePathMutations: typeof subscribeToSequenceNodePathMutations;
 };

package/dist/index.js

@@ -18,7 +18,9 @@ const package_manager_spawn_options_1 = require("./helpers/package-manager-spawn
 const max_timeline_tracks_1 = require("./max-timeline-tracks");
 const get_package_manager_1 = require("./preview-server/get-package-manager");
 const live_events_1 = require("./preview-server/live-events");
+const prerendered_scene_1 = require("./preview-server/prerendered-scene");
 const open_in_editor_1 = require("./preview-server/routes/open-in-editor");
+const sequence_node_path_mutation_1 = require("./preview-server/sequence-node-path-mutation");
 const update_available_1 = require("./preview-server/update-available");
 const remotion_skill_names_1 = require("./remotion-skill-names");
 Object.defineProperty(exports, "remotionSkillNames", { enumerable: true, get: function () { return remotion_skill_names_1.remotionSkillNames; } });
@@ -53,4 +55,6 @@ exports.StudioServerInternals = {
     parseRemotionSkillVersion: detect_outdated_remotion_skills_1.parseRemotionSkillVersion,
     remotionSkillNames: remotion_skill_names_1.remotionSkillNames,
     getEditorName: open_in_editor_1.getEditorName,
+    replaceWithPrerenderedVideo: prerendered_scene_1.replaceWithPrerenderedVideo,
+    subscribeToSequenceNodePathMutations: sequence_node_path_mutation_1.subscribeToSequenceNodePathMutations,
 };

package/dist/preview-server/api-routes.js

@@ -42,6 +42,7 @@ const open_in_terminal_1 = require("./routes/open-in-terminal");
 const paste_effects_1 = require("./routes/paste-effects");
 const precompose_jsx_nodes_1 = require("./routes/precompose-jsx-nodes");
 const prepare_element_install_1 = require("./routes/prepare-element-install");
+const prerendered_scene_info_1 = require("./routes/prerendered-scene-info");
 const project_info_1 = require("./routes/project-info");
 const redo_1 = require("./routes/redo");
 const register_client_render_1 = require("./routes/register-client-render");
@@ -55,6 +56,7 @@ const reorder_effect_1 = require("./routes/reorder-effect");
 const reorder_sequence_1 = require("./routes/reorder-sequence");
 const replace_video_source_1 = require("./routes/replace-video-source");
 const restart_studio_1 = require("./routes/restart-studio");
+const restore_prerendered_scene_1 = require("./routes/restore-prerendered-scene");
 const save_effect_props_1 = require("./routes/save-effect-props");
 const save_multiple_effect_props_1 = require("./routes/save-multiple-effect-props");
 const save_sequence_props_1 = require("./routes/save-sequence-props");
@@ -141,6 +143,8 @@ exports.allApiRoutes = {
     '/api/split-video-from-audio': split_video_from_audio_1.splitVideoFromAudioHandler,
     '/api/insert-basic-captions': insert_basic_captions_1.insertBasicCaptionsHandler,
     '/api/replace-video-source': replace_video_source_1.replaceVideoSourceHandler,
+    '/api/prerendered-scene-info': prerendered_scene_info_1.prerenderedSceneInfoHandler,
+    '/api/restore-prerendered-scene': restore_prerendered_scene_1.restorePrerenderedSceneHandler,
     '/api/update-available': update_available_1.handleUpdate,
     '/api/release-notes': release_notes_1.getReleaseNotesHandler,
     '/api/remotion-skills-info': remotion_skills_info_1.remotionSkillsInfoHandler,

package/dist/preview-server/commit-node-codemod.d.ts

@@ -0,0 +1,27 @@
+import type { CodemodProject, NodeReference } from '@remotion/codemods';
+import type { LogLevel } from '@remotion/renderer';
+import type { SequenceNodePathRemapping } from '@remotion/studio-shared';
+import type { SequenceNodePath } from 'remotion';
+import { type UndoEntryType } from './undo-stack';
+export declare const commitNodeCodemod: <Result extends {
+    changes: {
+        nextContents: string | null;
+    }[];
+    nodePathRemappings: SequenceNodePathRemapping[];
+    logLine: number;
+}>({ remotionRoot, logLevel, fileName, nodePath, codemod, label, entryType, }: {
+    remotionRoot: string;
+    logLevel: LogLevel;
+    fileName: string;
+    nodePath: SequenceNodePath;
+    codemod: (options: {
+        project: CodemodProject;
+        node: NodeReference;
+    }) => Result;
+    label: string;
+    entryType: UndoEntryType;
+}) => Promise<{
+    absolutePath: string;
+    nodePathMutation: import("@remotion/studio-shared").SequenceNodePathMutation;
+    result: Result;
+}>;

package/dist/preview-server/commit-node-codemod.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commitNodeCodemod = void 0;
+const node_fs_1 = require("node:fs");
+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 source_file_write_queue_1 = require("./routes/source-file-write-queue");
+const sequence_node_path_mutation_1 = require("./sequence-node-path-mutation");
+const undo_stack_1 = require("./undo-stack");
+const commitNodeCodemod = ({ remotionRoot, logLevel, fileName, nodePath, codemod, label, entryType, }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(() => {
+    var _a;
+    var _b;
+    const { absolutePath } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+        remotionRoot,
+        fileName,
+        action: 'modify',
+    });
+    const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
+    const result = codemod({
+        project: {
+            files: { [absolutePath]: fileContents },
+            rootDir: remotionRoot,
+        },
+        node: { filePath: absolutePath, nodePath },
+    });
+    const output = (_b = (_a = result.changes[0]) === null || _a === void 0 ? void 0 : _a.nextContents) !== null && _b !== void 0 ? _b : fileContents;
+    const { logLine } = result;
+    const nodePathRemappings = result.nodePathRemappings.map(({ oldNodePath, newNodePath, oldJsxName, newJsxName }) => ({
+        oldNodePath,
+        newNodePath,
+        oldJsxName,
+        newJsxName,
+    }));
+    const nodePathMutation = (0, sequence_node_path_mutation_1.broadcastSequenceNodePathMutation)([{ absolutePath, remappings: nodePathRemappings }], null);
+    (0, undo_stack_1.pushToUndoStack)({
+        filePath: absolutePath,
+        oldContents: fileContents,
+        newContents: output,
+        logLevel,
+        remotionRoot,
+        logLine,
+        description: {
+            undoMessage: `↩️  ${label}`,
+            redoMessage: `↪️  ${label}`,
+        },
+        entryType,
+        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)} ${label}`);
+    (0, undo_stack_1.printUndoHint)(logLevel);
+    return { absolutePath, nodePathMutation, result };
+});
+exports.commitNodeCodemod = commitNodeCodemod;

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

@@ -8,8 +8,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupWebpackHmr = void 0;
 const renderer_1 = require("@remotion/renderer");
 const hmr_timing_1 = require("../hmr-timing");
+const sequence_node_path_mutation_build_1 = require("../sequence-node-path-mutation-build");
 const setupWebpackHmr = (compiler, logLevel, liveEventsServer) => {
-    let latestStats = null;
+    let latestBuild = null;
+    const getSourceMutationId = (0, sequence_node_path_mutation_build_1.trackSequenceNodePathMutationBuilds)(compiler);
     const publishHmr = (hmrEvent) => {
         liveEventsServer.sendEventToClient({ type: 'hmr', hmrEvent });
     };
@@ -24,7 +26,7 @@ const setupWebpackHmr = (compiler, logLevel, liveEventsServer) => {
             logLevel,
             stage: 'compiler-invalid',
         });
-        latestStats = null;
+        latestBuild = null;
         renderer_1.RenderInternals.Log.info({ indent: false, logLevel }, 'Building...');
         publishHmr({
             action: 'building',
@@ -36,19 +38,20 @@ const setupWebpackHmr = (compiler, logLevel, liveEventsServer) => {
             logLevel,
             stage: 'compiler-done',
         });
+        const sourceMutationId = getSourceMutationId(statsResult);
         // Keep hold of latest stats so they can be propagated to new clients
-        latestStats = statsResult;
-        publishStats('built', latestStats, publishHmr);
+        latestBuild = { stats: statsResult, sourceMutationId };
+        publishStats('built', statsResult, sourceMutationId, publishHmr);
         (0, hmr_timing_1.logHmrTiming)({ detail: null, logLevel, stage: 'hmr-stats-published' });
     }
     liveEventsServer.addNewClientListener(() => {
-        if (latestStats) {
-            publishStats('sync', latestStats, publishHmr);
+        if (latestBuild) {
+            publishStats('sync', latestBuild.stats, latestBuild.sourceMutationId, publishHmr);
         }
     });
 };
 exports.setupWebpackHmr = setupWebpackHmr;
-function publishStats(action, statsResult, publishHmr) {
+function publishStats(action, statsResult, sourceMutationId, publishHmr) {
     var _a;
     // Studio uses a single compiler. Child compilations must not replace the
     // parent compilation's hash in the HMR message.
@@ -57,6 +60,7 @@ function publishStats(action, statsResult, publishHmr) {
         action,
         time: statsResult.endTime - statsResult.startTime,
         hash: statsResult.hash,
+        sourceMutationId,
         // Build diagnostics are printed by the dev middleware.
         warnings: [],
         errors: [],

package/dist/preview-server/prerendered-scene.d.ts

@@ -0,0 +1,25 @@
+import type { LogLevel } from '@remotion/renderer';
+import type { SequenceNodePath } from 'remotion';
+type PrerenderedSceneSidecar = {
+    compositionId: string;
+    source: string;
+    importStatements: string[];
+    sceneFile: string | null;
+    sceneFileHash: string | null;
+};
+export declare const getPrerenderedSceneSidecarFile: (videoFile: string) => string;
+export declare const readPrerenderedSceneSidecar: ({ publicDir, src, }: {
+    publicDir: string;
+    src: string;
+}) => PrerenderedSceneSidecar | null;
+export declare const hashSceneFile: (file: string) => string;
+export declare const replaceWithPrerenderedVideo: ({ remotionRoot, logLevel, fileName, nodePath, src, videoFile, compositionId, }: {
+    remotionRoot: string;
+    logLevel: LogLevel;
+    fileName: string;
+    nodePath: SequenceNodePath;
+    src: string;
+    videoFile: string;
+    compositionId: string;
+}) => Promise<void>;
+export {};

package/dist/preview-server/prerendered-scene.js

@@ -0,0 +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.replaceWithPrerenderedVideo = exports.hashSceneFile = exports.readPrerenderedSceneSidecar = exports.getPrerenderedSceneSidecarFile = 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 codemods_1 = require("@remotion/codemods");
+const commit_node_codemod_1 = require("./commit-node-codemod");
+const getPrerenderedSceneSidecarFile = (videoFile) => `${videoFile}.json`;
+exports.getPrerenderedSceneSidecarFile = getPrerenderedSceneSidecarFile;
+const readPrerenderedSceneSidecar = ({ publicDir, src, }) => {
+    const videoFile = node_path_1.default.resolve(publicDir, src);
+    const relativeToPublicDir = node_path_1.default.relative(publicDir, videoFile);
+    if (relativeToPublicDir.startsWith('..') ||
+        node_path_1.default.isAbsolute(relativeToPublicDir)) {
+        return null;
+    }
+    const sidecarFile = (0, exports.getPrerenderedSceneSidecarFile)(videoFile);
+    if (!(0, node_fs_1.existsSync)(sidecarFile)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(sidecarFile, 'utf-8'));
+    }
+    catch (_a) {
+        return null;
+    }
+};
+exports.readPrerenderedSceneSidecar = readPrerenderedSceneSidecar;
+const hashSceneFile = (file) => (0, node_crypto_1.createHash)('sha256')
+    .update((0, node_fs_1.readFileSync)(file, 'utf-8'))
+    .digest('hex')
+    .slice(0, 16);
+exports.hashSceneFile = hashSceneFile;
+const resolveSceneFile = (importingFile, importSource) => {
+    var _a;
+    if (!importSource.startsWith('.')) {
+        return null;
+    }
+    const base = node_path_1.default.resolve(node_path_1.default.dirname(importingFile), importSource);
+    const extensions = ['.tsx', '.ts', '.jsx', '.js', '.mjs'];
+    return ((_a = [
+        base,
+        ...extensions.map((extension) => base + extension),
+        ...extensions.map((extension) => node_path_1.default.join(base, `index${extension}`)),
+    ].find((file) => (0, node_fs_1.existsSync)(file) && (0, node_fs_1.statSync)(file).isFile())) !== null && _a !== void 0 ? _a : null);
+};
+const replaceWithPrerenderedVideo = async ({ remotionRoot, logLevel, fileName, nodePath, src, videoFile, compositionId, }) => {
+    const { absolutePath, result } = await (0, commit_node_codemod_1.commitNodeCodemod)({
+        remotionRoot,
+        logLevel,
+        fileName,
+        nodePath,
+        codemod: ({ project, node }) => codemods_1.CodemodsInternals.replaceNodeChild({
+            project,
+            node,
+            element: (0, codemods_1.createElement)({
+                component: 'Video',
+                importPath: '@remotion/media',
+                props: { src: (0, codemods_1.staticFileValue)(src) },
+            }),
+        }),
+        label: 'Rendered and replaced scene',
+        entryType: 'prerender',
+    });
+    const sceneFile = result.sceneImportSource === null
+        ? null
+        : resolveSceneFile(absolutePath, result.sceneImportSource);
+    const sidecar = {
+        compositionId,
+        source: result.replacedSource,
+        importStatements: result.replacedImports,
+        sceneFile: sceneFile === null
+            ? null
+            : node_path_1.default.relative(remotionRoot, sceneFile).split(node_path_1.default.sep).join('/'),
+        sceneFileHash: sceneFile === null ? null : (0, exports.hashSceneFile)(sceneFile),
+    };
+    // Written atomically so that a partially written sidecar is never read
+    const sidecarFile = (0, exports.getPrerenderedSceneSidecarFile)(videoFile);
+    (0, node_fs_1.writeFileSync)(`${sidecarFile}.tmp`, JSON.stringify(sidecar, null, 2) + '\n');
+    (0, node_fs_1.renameSync)(`${sidecarFile}.tmp`, sidecarFile);
+};
+exports.replaceWithPrerenderedVideo = replaceWithPrerenderedVideo;

package/dist/preview-server/resolve-compiled-sequence-paths.d.ts

@@ -0,0 +1,12 @@
+import type { SequenceNodePath } from 'remotion';
+export declare const resolveCompiledSequencePaths: ({ fileName, remotionRoot, fileContentsCache, targets, }: {
+    fileName: string;
+    remotionRoot: string;
+    fileContentsCache: Map<string, string>;
+    targets: {
+        index: number;
+        hash: string;
+        line: number;
+        column: number;
+    }[];
+}) => Map<number, SequenceNodePath | null>;

package/dist/preview-server/resolve-compiled-sequence-paths.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCompiledSequencePaths = void 0;
+const node_crypto_1 = require("node:crypto");
+const codemods_1 = require("@remotion/codemods");
+const read_source_file_1 = require("../helpers/read-source-file");
+const resolve_file_inside_project_1 = require("../helpers/resolve-file-inside-project");
+const undo_stack_1 = require("./undo-stack");
+const resolveCompiledSequencePaths = ({ fileName, remotionRoot, fileContentsCache, targets, }) => {
+    var _a;
+    const { absolutePath } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+        remotionRoot,
+        fileName,
+        action: 'read',
+    });
+    const current = (0, read_source_file_1.readSourceFile)({ absolutePath, fileContentsCache });
+    const results = new Map();
+    const hashes = new Map();
+    const snapshots = new Map();
+    const inspect = (contents) => {
+        const cached = snapshots.get(contents);
+        if (cached !== undefined)
+            return cached;
+        try {
+            const nodes = (0, codemods_1.getNodes)({
+                project: { rootDir: remotionRoot, files: { [absolutePath]: contents } },
+                filePath: absolutePath,
+            });
+            const locations = new Map();
+            for (const { nodePath, location } of nodes) {
+                if (!location)
+                    continue;
+                const key = `${location.line}:${location.column}`;
+                locations.set(key, locations.has(key) ? null : nodePath);
+            }
+            const snapshot = {
+                locations,
+                structure: JSON.stringify(nodes.map((n) => [n.nodePath, n.tagName, n.componentIdentity])),
+            };
+            snapshots.set(contents, snapshot);
+            return snapshot;
+        }
+        catch (_a) {
+            snapshots.set(contents, null);
+            return null;
+        }
+    };
+    const matchingTargets = new Map();
+    for (const target of targets) {
+        const group = (_a = matchingTargets.get(target.hash)) !== null && _a !== void 0 ? _a : [];
+        group.push(target);
+        matchingTargets.set(target.hash, group);
+    }
+    const acceptSnapshot = (contents, towardCurrent) => {
+        var _a;
+        var _b;
+        let hash = hashes.get(contents);
+        if (!hash) {
+            hash = (0, node_crypto_1.createHash)('sha256').update(contents).digest('hex');
+            hashes.set(contents, hash);
+        }
+        const group = matchingTargets.get(hash);
+        if (!group)
+            return;
+        const locations = (_a = inspect(contents)) === null || _a === void 0 ? void 0 : _a.locations;
+        const maps = towardCurrent.map((step) => {
+            if (step.remappings === null) {
+                // Props edits preserve JSX order, but pasted expressions can insert
+                // hooks. Without an explicit mapping every JSX path must still match.
+                const before = inspect(step.from);
+                const after = inspect(step.to);
+                return before !== null && before.structure === (after === null || after === void 0 ? void 0 : after.structure)
+                    ? new Map()
+                    : null;
+            }
+            const paths = new Map();
+            const destinations = new Set();
+            for (const { oldNodePath, newNodePath } of step.remappings) {
+                const from = step.reverse ? newNodePath : oldNodePath;
+                const to = step.reverse ? oldNodePath : newNodePath;
+                if (to !== null) {
+                    const destination = JSON.stringify(to);
+                    if (destinations.has(destination))
+                        return null;
+                    destinations.add(destination);
+                }
+                if (from === null)
+                    continue;
+                const key = JSON.stringify(from);
+                if (paths.has(key))
+                    return null;
+                paths.set(key, to);
+            }
+            // If a different node took a path, its former occupant cannot
+            // have survived there, even if the remapping omitted that occupant.
+            for (const key of destinations) {
+                if (!paths.has(key))
+                    paths.set(key, null);
+            }
+            return paths;
+        });
+        for (const target of group) {
+            let nodePath = (_b = locations === null || locations === void 0 ? void 0 : locations.get(`${target.line}:${target.column}`)) !== null && _b !== void 0 ? _b : null;
+            for (let i = maps.length - 1; nodePath !== null && i >= 0; i--) {
+                const map = maps[i];
+                if (map === null) {
+                    nodePath = null;
+                    break;
+                }
+                const moved = map.get(JSON.stringify(nodePath));
+                if (moved !== undefined)
+                    nodePath = moved;
+            }
+            // An identical source can occur on both sides of Undo. If those
+            // histories disagree, that hash cannot identify the live element.
+            const previous = results.get(target.index);
+            results.set(target.index, previous === undefined ||
+                JSON.stringify(previous) === JSON.stringify(nodePath)
+                ? nodePath
+                : null);
+        }
+    };
+    acceptSnapshot(current, []);
+    for (const [entries, reverse] of [
+        [(0, undo_stack_1.getUndoStack)(), false],
+        [(0, undo_stack_1.getRedoStack)(), true],
+    ]) {
+        let contents = current;
+        const changes = [];
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const entry = entries[i];
+            const snapshot = entry.snapshots.find((s) => s.filePath === absolutePath);
+            if (!snapshot)
+                continue;
+            const from = reverse ? snapshot.newContents : snapshot.oldContents;
+            const to = reverse ? snapshot.oldContents : snapshot.newContents;
+            if (from === null ||
+                to !== contents ||
+                (snapshot.nodePathRemappings === null &&
+                    entry.entryType !== 'sequence-props' &&
+                    entry.entryType !== 'effect-props'))
+                break;
+            changes.push({
+                from,
+                to,
+                reverse,
+                remappings: snapshot.nodePathRemappings,
+            });
+            acceptSnapshot(from, changes);
+            contents = from;
+        }
+    }
+    return results;
+};
+exports.resolveCompiledSequencePaths = resolveCompiledSequencePaths;

package/dist/preview-server/routes/add-effect-keyframe.js

@@ -48,7 +48,7 @@ const addEffectKeyframeHandler = ({ input: { fileName, sequenceNodePath, effectI
     (0, undo_stack_1.pushToUndoStack)({
         filePath: absolutePath,
         oldContents: fileContents,
-        newContents: null,
+        newContents: output,
         logLevel,
         remotionRoot,
         logLine,

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

@@ -4,7 +4,6 @@ exports.addKeyframesHandler = exports.addKeyframes = void 0;
 const node_fs_1 = require("node:fs");
 const renderer_1 = require("@remotion/renderer");
 const get_node_path_remappings_1 = require("../../codemods/get-node-path-remappings");
-const parse_ast_1 = require("../../codemods/parse-ast");
 const update_keyframes_1 = require("../../codemods/update-keyframes/update-keyframes");
 const file_watcher_1 = require("../../file-watcher");
 const resolve_file_inside_project_1 = require("../../helpers/resolve-file-inside-project");
@@ -89,7 +88,7 @@ const addKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remo
         const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
         let output = fileContents;
         let firstLogLine = Number.POSITIVE_INFINITY;
-        const originalNodes = (0, get_node_path_remappings_1.captureJsxNodePaths)((0, parse_ast_1.parseAst)(fileContents));
+        const originalNodes = (0, get_node_path_remappings_1.captureJsxNodePaths)(fileContents);
         // Keyframe codemods may wrap a concise arrow in a return statement.
         // JSX nodes remain in order, but their node paths can all change.
         const currentPathFor = (originalPath) => {
@@ -97,7 +96,7 @@ const addKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remo
             if (index === -1) {
                 throw new Error('Could not find the original JSX node for keyframing');
             }
-            const currentNodes = (0, get_node_path_remappings_1.captureJsxNodePaths)((0, parse_ast_1.parseAst)(output));
+            const currentNodes = (0, get_node_path_remappings_1.captureJsxNodePaths)(output);
             if (currentNodes.length !== originalNodes.length) {
                 throw new Error('Could not remap JSX nodes after keyframing');
             }
@@ -169,7 +168,7 @@ const addKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remo
                 });
             }
         }
-        const finalNodes = (0, get_node_path_remappings_1.captureJsxNodePaths)((0, parse_ast_1.parseAst)(output));
+        const finalNodes = (0, get_node_path_remappings_1.captureJsxNodePaths)(output);
         if (finalNodes.length !== originalNodes.length) {
             throw new Error('Could not remap JSX nodes after keyframing');
         }
@@ -178,11 +177,20 @@ const addKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remo
             oldContents: fileContents,
             newContents: output,
             logLine: Number.isFinite(firstLogLine) ? firstLogLine : 1,
-            nodePathRemappings: originalNodes.flatMap(({ nodePath }, index) => {
-                const newNodePath = finalNodes[index].nodePath;
-                return JSON.stringify(nodePath) === JSON.stringify(newNodePath)
+            nodePathRemappings: originalNodes.flatMap(({ location, nodePath }, index) => {
+                var _a, _b;
+                const next = finalNodes[index];
+                return (location === null || location === void 0 ? void 0 : location.line) === ((_a = next.location) === null || _a === void 0 ? void 0 : _a.line) &&
+                    (location === null || location === void 0 ? void 0 : location.column) === ((_b = next.location) === null || _b === void 0 ? void 0 : _b.column) &&
+                    JSON.stringify(nodePath) === JSON.stringify(next.nodePath)
                     ? []
-                    : [{ oldNodePath: nodePath, newNodePath }];
+                    : [
+                        {
+                            oldNodePath: nodePath,
+                            newNodePath: next.nodePath,
+                            sourceLocations: { before: location, after: next.location },
+                        },
+                    ];
             }),
         });
     }
@@ -231,7 +239,7 @@ const addKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remo
         });
     }
     const nodePathMutation = filesWithRemappings.length
-        ? (0, sequence_node_path_mutation_1.broadcastSequenceNodePathMutation)(filesWithRemappings, null)
+        ? (0, sequence_node_path_mutation_1.broadcastSequenceNodePathMutation)(filesWithRemappings, null, true)
         : null;
     for (const log of sequenceLogs) {
         (0, log_update_1.logUpdate)({