@remotion/studio-server 4.0.434 → 4.0.436

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

@@ -0,0 +1,12 @@
+import type { CanUpdateDefaultPropsResponse } from '@remotion/studio-shared';
+export declare const subscribeToDefaultPropsWatchers: ({ compositionId, clientId, remotionRoot, entryPoint, }: {
+    compositionId: string;
+    clientId: string;
+    remotionRoot: string;
+    entryPoint: string;
+}) => Promise<CanUpdateDefaultPropsResponse>;
+export declare const unsubscribeFromDefaultPropsWatchers: ({ compositionId, clientId, }: {
+    compositionId: string;
+    clientId: string;
+}) => void;
+export declare const unsubscribeClientDefaultPropsWatchers: (clientId: string) => void;

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeClientDefaultPropsWatchers = exports.unsubscribeFromDefaultPropsWatchers = exports.subscribeToDefaultPropsWatchers = void 0;
+const file_watcher_1 = require("../file-watcher");
+const live_events_1 = require("./live-events");
+const can_update_default_props_1 = require("./routes/can-update-default-props");
+// Global file watcher — at most one for the root file
+let globalWatcher = null;
+// Per-compositionId set of subscribed clientIds
+const subscriptions = {};
+// Cached config for recomputation on file change
+let watcherConfig = null;
+const ensureGlobalWatcher = (rootFile) => {
+    if (globalWatcher) {
+        globalWatcher.refCount++;
+        return;
+    }
+    const { unwatch } = (0, file_watcher_1.installFileWatcher)({
+        file: rootFile,
+        onChange: (type) => {
+            if (type === 'deleted') {
+                return;
+            }
+            if (!watcherConfig) {
+                return;
+            }
+            const compositionIds = Object.keys(subscriptions);
+            for (const compositionId of compositionIds) {
+                if (subscriptions[compositionId].size === 0) {
+                    continue;
+                }
+                const clientIds = [...subscriptions[compositionId]];
+                (0, can_update_default_props_1.computeCanUpdateDefaultProps)({
+                    compositionId,
+                    remotionRoot: watcherConfig.remotionRoot,
+                    entryPoint: watcherConfig.entryPoint,
+                }).then(({ result: newResult }) => {
+                    (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+                        const event = {
+                            type: 'default-props-updatable-changed',
+                            compositionId,
+                            result: newResult,
+                        };
+                        for (const cId of clientIds) {
+                            listener.sendEventToClientId(cId, event);
+                        }
+                    });
+                });
+            }
+        },
+    });
+    globalWatcher = { unwatch, rootFile, refCount: 1 };
+};
+const releaseGlobalWatcher = () => {
+    if (!globalWatcher) {
+        return;
+    }
+    globalWatcher.refCount--;
+    if (globalWatcher.refCount <= 0) {
+        globalWatcher.unwatch();
+        globalWatcher = null;
+        watcherConfig = null;
+    }
+};
+const subscribeToDefaultPropsWatchers = async ({ compositionId, clientId, remotionRoot, entryPoint, }) => {
+    var _a;
+    const { result, rootFile } = await (0, can_update_default_props_1.computeCanUpdateDefaultProps)({
+        compositionId,
+        remotionRoot,
+        entryPoint,
+    });
+    // Remove from any previous subscription for this client+composition
+    if ((_a = subscriptions[compositionId]) === null || _a === void 0 ? void 0 : _a.has(clientId)) {
+        subscriptions[compositionId].delete(clientId);
+        releaseGlobalWatcher();
+    }
+    if (rootFile) {
+        watcherConfig = { remotionRoot, entryPoint };
+        if (!subscriptions[compositionId]) {
+            subscriptions[compositionId] = new Set();
+        }
+        subscriptions[compositionId].add(clientId);
+        ensureGlobalWatcher(rootFile);
+    }
+    return result;
+};
+exports.subscribeToDefaultPropsWatchers = subscribeToDefaultPropsWatchers;
+const unsubscribeFromDefaultPropsWatchers = ({ compositionId, clientId, }) => {
+    var _a;
+    if (!((_a = subscriptions[compositionId]) === null || _a === void 0 ? void 0 : _a.has(clientId))) {
+        return;
+    }
+    subscriptions[compositionId].delete(clientId);
+    if (subscriptions[compositionId].size === 0) {
+        delete subscriptions[compositionId];
+    }
+    releaseGlobalWatcher();
+};
+exports.unsubscribeFromDefaultPropsWatchers = unsubscribeFromDefaultPropsWatchers;
+const unsubscribeClientDefaultPropsWatchers = (clientId) => {
+    for (const compositionId of Object.keys(subscriptions)) {
+        if (subscriptions[compositionId].has(clientId)) {
+            subscriptions[compositionId].delete(clientId);
+            if (subscriptions[compositionId].size === 0) {
+                delete subscriptions[compositionId];
+            }
+            releaseGlobalWatcher();
+        }
+    }
+};
+exports.unsubscribeClientDefaultPropsWatchers = unsubscribeClientDefaultPropsWatchers;

package/dist/preview-server/routes/redo.d.ts

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redoHandler = void 0;
+const undo_stack_1 = require("../undo-stack");
+const redoHandler = () => {
+    return Promise.resolve((0, undo_stack_1.popRedo)());
+};
+exports.redoHandler = redoHandler;

package/dist/preview-server/routes/subscribe-to-default-props.d.ts

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

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscribeToDefaultProps = void 0;
+const default_props_watchers_1 = require("../default-props-watchers");
+const subscribeToDefaultProps = ({ input: { compositionId, clientId }, remotionRoot, entryPoint }) => {
+    return (0, default_props_watchers_1.subscribeToDefaultPropsWatchers)({
+        compositionId,
+        clientId,
+        remotionRoot,
+        entryPoint,
+    });
+};
+exports.subscribeToDefaultProps = subscribeToDefaultProps;

package/dist/preview-server/routes/undo.d.ts

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

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undoHandler = void 0;
+const undo_stack_1 = require("../undo-stack");
+const undoHandler = () => {
+    return Promise.resolve((0, undo_stack_1.popUndo)());
+};
+exports.undoHandler = undoHandler;

package/dist/preview-server/routes/unsubscribe-from-default-props.d.ts

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

package/dist/preview-server/routes/unsubscribe-from-default-props.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsubscribeFromDefaultProps = void 0;
+const default_props_watchers_1 = require("../default-props-watchers");
+const unsubscribeFromDefaultProps = ({ input: { compositionId, clientId } }) => {
+    (0, default_props_watchers_1.unsubscribeFromDefaultPropsWatchers)({
+        compositionId,
+        clientId,
+    });
+    return Promise.resolve(undefined);
+};
+exports.unsubscribeFromDefaultProps = unsubscribeFromDefaultProps;

package/dist/preview-server/undo-stack.d.ts

@@ -0,0 +1,23 @@
+import type { LogLevel } from '@remotion/renderer';
+interface UndoEntry {
+    filePath: string;
+    oldContents: string;
+}
+export declare function pushToUndoStack(filePath: string, oldContents: string, logLevel: LogLevel): void;
+export declare function pushToRedoStack(filePath: string, oldContents: string): void;
+export declare function suppressUndoStackInvalidation(filePath: string): void;
+export declare function popUndo(): {
+    success: true;
+} | {
+    success: false;
+    reason: string;
+};
+export declare function popRedo(): {
+    success: true;
+} | {
+    success: false;
+    reason: string;
+};
+export declare function getUndoStack(): readonly UndoEntry[];
+export declare function getRedoStack(): readonly UndoEntry[];
+export {};

package/dist/preview-server/undo-stack.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushToUndoStack = pushToUndoStack;
+exports.pushToRedoStack = pushToRedoStack;
+exports.suppressUndoStackInvalidation = suppressUndoStackInvalidation;
+exports.popUndo = popUndo;
+exports.popRedo = popRedo;
+exports.getUndoStack = getUndoStack;
+exports.getRedoStack = getRedoStack;
+const node_fs_1 = require("node:fs");
+const renderer_1 = require("@remotion/renderer");
+const file_watcher_1 = require("../file-watcher");
+const hmr_suppression_1 = require("./hmr-suppression");
+const live_events_1 = require("./live-events");
+const MAX_ENTRIES = 100;
+const undoStack = [];
+const redoStack = [];
+const suppressedWrites = new Map();
+const watchers = new Map();
+let storedLogLevel = 'info';
+function broadcastState() {
+    const undoFile = undoStack.length > 0 ? undoStack[undoStack.length - 1].filePath : null;
+    const redoFile = redoStack.length > 0 ? redoStack[redoStack.length - 1].filePath : null;
+    (0, live_events_1.waitForLiveEventsListener)().then((listener) => {
+        listener.sendEventToClient({
+            type: 'undo-redo-stack-changed',
+            undoFile,
+            redoFile,
+        });
+    });
+}
+function pushToUndoStack(filePath, oldContents, logLevel) {
+    storedLogLevel = logLevel;
+    undoStack.push({ filePath, oldContents });
+    if (undoStack.length > MAX_ENTRIES) {
+        undoStack.shift();
+    }
+    redoStack.length = 0;
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel }, renderer_1.RenderInternals.chalk.gray(`Undo stack: added entry for ${filePath} (${undoStack.length} items)`));
+    ensureWatching(filePath);
+    broadcastState();
+}
+function pushToRedoStack(filePath, oldContents) {
+    redoStack.push({ filePath, oldContents });
+    if (redoStack.length > MAX_ENTRIES) {
+        redoStack.shift();
+    }
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: storedLogLevel }, renderer_1.RenderInternals.chalk.gray(`Redo stack: added entry for ${filePath} (${redoStack.length} items)`));
+    ensureWatching(filePath);
+    broadcastState();
+}
+function suppressUndoStackInvalidation(filePath) {
+    var _a;
+    suppressedWrites.set(filePath, ((_a = suppressedWrites.get(filePath)) !== null && _a !== void 0 ? _a : 0) + 1);
+}
+function ensureWatching(filePath) {
+    if (watchers.has(filePath)) {
+        return;
+    }
+    const watcher = (0, file_watcher_1.installFileWatcher)({
+        file: filePath,
+        onChange: () => {
+            var _a;
+            const count = (_a = suppressedWrites.get(filePath)) !== null && _a !== void 0 ? _a : 0;
+            if (count > 0) {
+                if (count === 1) {
+                    suppressedWrites.delete(filePath);
+                }
+                else {
+                    suppressedWrites.set(filePath, count - 1);
+                }
+                return;
+            }
+            invalidateForFile(filePath);
+        },
+    });
+    watchers.set(filePath, watcher);
+}
+function invalidateForFile(filePath) {
+    let changed = false;
+    let lastUndoIndex = -1;
+    for (let i = undoStack.length - 1; i >= 0; i--) {
+        if (undoStack[i].filePath === filePath) {
+            lastUndoIndex = i;
+            break;
+        }
+    }
+    if (lastUndoIndex !== -1) {
+        const removed = lastUndoIndex + 1;
+        undoStack.splice(0, removed);
+        changed = true;
+        renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: storedLogLevel }, renderer_1.RenderInternals.chalk.gray(`Undo stack: ${filePath} was externally modified, removed ${removed} entries (${undoStack.length} items)`));
+    }
+    let lastRedoIndex = -1;
+    for (let i = redoStack.length - 1; i >= 0; i--) {
+        if (redoStack[i].filePath === filePath) {
+            lastRedoIndex = i;
+            break;
+        }
+    }
+    if (lastRedoIndex !== -1) {
+        const removed = lastRedoIndex + 1;
+        redoStack.splice(0, removed);
+        changed = true;
+        renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: storedLogLevel }, renderer_1.RenderInternals.chalk.gray(`Redo stack: ${filePath} was externally modified, removed ${removed} entries (${redoStack.length} items)`));
+    }
+    cleanupWatchers();
+    if (changed) {
+        broadcastState();
+    }
+}
+function cleanupWatchers() {
+    const filesInStacks = new Set([
+        ...undoStack.map((e) => e.filePath),
+        ...redoStack.map((e) => e.filePath),
+    ]);
+    for (const [filePath, watcher] of watchers) {
+        if (!filesInStacks.has(filePath)) {
+            watcher.unwatch();
+            watchers.delete(filePath);
+        }
+    }
+}
+function popUndo() {
+    const entry = undoStack.pop();
+    if (!entry) {
+        return { success: false, reason: 'Nothing to undo' };
+    }
+    const currentContents = (0, node_fs_1.readFileSync)(entry.filePath, 'utf-8');
+    redoStack.push({ filePath: entry.filePath, oldContents: currentContents });
+    suppressUndoStackInvalidation(entry.filePath);
+    (0, hmr_suppression_1.suppressHmrForFile)(entry.filePath);
+    (0, node_fs_1.writeFileSync)(entry.filePath, entry.oldContents);
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: storedLogLevel }, renderer_1.RenderInternals.chalk.gray(`Undo: restored ${entry.filePath} (undo: ${undoStack.length}, redo: ${redoStack.length})`));
+    ensureWatching(entry.filePath);
+    broadcastState();
+    return { success: true };
+}
+function popRedo() {
+    const entry = redoStack.pop();
+    if (!entry) {
+        return { success: false, reason: 'Nothing to redo' };
+    }
+    const currentContents = (0, node_fs_1.readFileSync)(entry.filePath, 'utf-8');
+    undoStack.push({ filePath: entry.filePath, oldContents: currentContents });
+    suppressUndoStackInvalidation(entry.filePath);
+    (0, hmr_suppression_1.suppressHmrForFile)(entry.filePath);
+    (0, node_fs_1.writeFileSync)(entry.filePath, entry.oldContents);
+    renderer_1.RenderInternals.Log.verbose({ indent: false, logLevel: storedLogLevel }, renderer_1.RenderInternals.chalk.gray(`Redo: restored ${entry.filePath} (undo: ${undoStack.length}, redo: ${redoStack.length})`));
+    ensureWatching(entry.filePath);
+    broadcastState();
+    return { success: true };
+}
+function getUndoStack() {
+    return undoStack;
+}
+function getRedoStack() {
+    return redoStack;
+}

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/studio-server"
 	},
 	"name": "@remotion/studio-server",
-	"version": "4.0.434",
+	"version": "4.0.436",
 	"description": "Run a Remotion Studio with a server backend",
 	"main": "dist",
 	"sideEffects": false,
@@ -27,11 +27,11 @@
 		"@babel/parser": "7.24.1",
 		"semver": "7.5.3",
 		"prettier": "3.8.1",
-		"remotion": "4.0.434",
+		"remotion": "4.0.436",
 		"recast": "0.23.11",
-		"@remotion/bundler": "4.0.434",
-		"@remotion/renderer": "4.0.434",
-		"@remotion/studio-shared": "4.0.434",
+		"@remotion/bundler": "4.0.436",
+		"@remotion/renderer": "4.0.436",
+		"@remotion/studio-shared": "4.0.436",
 		"memfs": "3.4.3",
 		"source-map": "0.7.3",
 		"open": "^8.4.2"
@@ -41,7 +41,7 @@
 		"react": "19.2.3",
 		"@babel/types": "7.24.0",
 		"@types/semver": "^7.3.4",
-		"@remotion/eslint-config-internal": "4.0.434",
+		"@remotion/eslint-config-internal": "4.0.436",
 		"eslint": "9.19.0",
 		"@types/node": "20.12.14",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"