@remotion/studio-server 4.0.471 → 4.0.473

package/dist/preview-server/routes/download-remote-asset.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadRemoteAssetHandler = exports.getRemoteAssetFilename = void 0;
+const promises_1 = require("node:dns/promises");
+const node_fs_1 = require("node:fs");
+const node_net_1 = require("node:net");
+const node_path_1 = __importDefault(require("node:path"));
+const studio_shared_1 = require("@remotion/studio-shared");
+const validate_same_origin_1 = require("../validate-same-origin");
+const maxRemoteAssetSize = 50 * 1024 * 1024;
+const remoteAssetDownloadTimeout = 15000;
+const maxRemoteAssetRedirects = 5;
+const remoteAssetAcceptHeader = 'image/png,image/jpeg,image/webp,image/bmp,image/gif';
+const extensionsForFileType = {
+    png: ['png'],
+    jpeg: ['jpg', 'jpeg'],
+    webp: ['webp'],
+    bmp: ['bmp'],
+    gif: ['gif'],
+};
+const safeDecodeURIComponent = (value) => {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch (_a) {
+        return value;
+    }
+};
+const sanitizeAssetFilename = (filename) => {
+    return Array.from(filename)
+        .map((character) => {
+        const charCode = character.charCodeAt(0);
+        return charCode <= 31 || '<>:"/\\|?*'.includes(character)
+            ? '-'
+            : character;
+    })
+        .join('')
+        .trim()
+        .replace(/^[. ]+|[. ]+$/g, '');
+};
+const getRemoteAssetFilename = ({ fileType, url, }) => {
+    const basename = safeDecodeURIComponent(node_path_1.default.posix.basename(url.pathname));
+    const sanitized = sanitizeAssetFilename(basename);
+    const filenameWithoutFallback = sanitized === '' ? 'image' : sanitized;
+    const extensions = extensionsForFileType[fileType.type];
+    const extension = node_path_1.default
+        .extname(filenameWithoutFallback)
+        .slice(1)
+        .toLowerCase();
+    if (extensions.includes(extension)) {
+        return filenameWithoutFallback;
+    }
+    const withoutExtension = extension
+        ? filenameWithoutFallback.slice(0, -(extension.length + 1))
+        : filenameWithoutFallback;
+    const safeName = withoutExtension === '' ? 'image' : withoutExtension;
+    return `${safeName}.${extensions[0]}`;
+};
+exports.getRemoteAssetFilename = getRemoteAssetFilename;
+const isForbiddenIpv4Address = (address) => {
+    const parts = address.split('.').map((part) => Number(part));
+    if (parts.length !== 4 ||
+        parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+        return true;
+    }
+    const [first, second] = parts;
+    return (first === 0 ||
+        first === 10 ||
+        first === 127 ||
+        (first === 100 && second >= 64 && second <= 127) ||
+        (first === 169 && second === 254) ||
+        (first === 172 && second >= 16 && second <= 31) ||
+        (first === 192 && second === 168) ||
+        (first === 198 && (second === 18 || second === 19)) ||
+        first >= 224);
+};
+const isForbiddenIpv6Address = (address) => {
+    var _a;
+    const normalized = address.toLowerCase();
+    const mappedIpv4 = (_a = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/)) === null || _a === void 0 ? void 0 : _a[1];
+    if (mappedIpv4) {
+        return isForbiddenIpv4Address(mappedIpv4);
+    }
+    return (normalized === '::' ||
+        normalized === '::1' ||
+        normalized.startsWith('fc') ||
+        normalized.startsWith('fd') ||
+        normalized.startsWith('fe8') ||
+        normalized.startsWith('fe9') ||
+        normalized.startsWith('fea') ||
+        normalized.startsWith('feb'));
+};
+const ensureRemoteUrlIsAllowed = async (url) => {
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new Error('Only HTTP(S) URLs can be imported');
+    }
+    if (url.username !== '' || url.password !== '') {
+        throw new Error('Remote asset URLs cannot include credentials');
+    }
+    if (url.hostname === 'localhost' || url.hostname.endsWith('.localhost')) {
+        throw new Error('Localhost URLs cannot be imported');
+    }
+    const hostnameAsIp = (0, node_net_1.isIP)(url.hostname);
+    if (hostnameAsIp === 4 && isForbiddenIpv4Address(url.hostname)) {
+        throw new Error('Private IP addresses cannot be imported');
+    }
+    if (hostnameAsIp === 6 && isForbiddenIpv6Address(url.hostname)) {
+        throw new Error('Private IP addresses cannot be imported');
+    }
+    const addresses = hostnameAsIp
+        ? [{ address: url.hostname, family: hostnameAsIp }]
+        : await (0, promises_1.lookup)(url.hostname, { all: true });
+    if (addresses.length === 0) {
+        throw new Error(`Could not resolve ${url.hostname}`);
+    }
+    for (const address of addresses) {
+        if ((address.family === 4 && isForbiddenIpv4Address(address.address)) ||
+            (address.family === 6 && isForbiddenIpv6Address(address.address))) {
+            throw new Error('Private IP addresses cannot be imported');
+        }
+    }
+};
+const fetchRemoteAsset = async ({ signal, url, }) => {
+    var _a;
+    let currentUrl = url;
+    for (let redirects = 0; redirects <= maxRemoteAssetRedirects; redirects++) {
+        await ensureRemoteUrlIsAllowed(currentUrl);
+        const response = await fetch(currentUrl, {
+            headers: {
+                accept: remoteAssetAcceptHeader,
+            },
+            redirect: 'manual',
+            signal,
+        });
+        if (response.status < 300 || response.status >= 400) {
+            return response;
+        }
+        const location = response.headers.get('location');
+        if (location === null) {
+            throw new Error('Remote asset redirect is missing a Location header');
+        }
+        if (redirects === maxRemoteAssetRedirects) {
+            throw new Error('Remote asset redirected too many times');
+        }
+        await ((_a = response.body) === null || _a === void 0 ? void 0 : _a.cancel());
+        currentUrl = new URL(location, currentUrl);
+    }
+    throw new Error('Remote asset redirected too many times');
+};
+const readRemoteAsset = async ({ response, abort, }) => {
+    const contentLength = response.headers.get('content-length');
+    if (contentLength !== null && Number(contentLength) > maxRemoteAssetSize) {
+        abort();
+        throw new Error('Remote asset exceeds the 50MB size limit');
+    }
+    if (!response.body) {
+        const buffer = await response.arrayBuffer();
+        if (buffer.byteLength > maxRemoteAssetSize) {
+            throw new Error('Remote asset exceeds the 50MB size limit');
+        }
+        return new Uint8Array(buffer);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        if (!value) {
+            continue;
+        }
+        size += value.byteLength;
+        if (size > maxRemoteAssetSize) {
+            abort();
+            await reader.cancel();
+            throw new Error('Remote asset exceeds the 50MB size limit');
+        }
+        chunks.push(value);
+    }
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+};
+const downloadRemoteAssetHandler = async ({ input, publicDir, request }) => {
+    (0, validate_same_origin_1.validateSameOrigin)(request);
+    if (typeof input.url !== 'string') {
+        throw new Error('No `url` provided');
+    }
+    if (typeof fetch !== 'function') {
+        throw new Error('Downloading remote assets requires Node.js 18 or newer. Drag a local file instead.');
+    }
+    const url = new URL(input.url);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, remoteAssetDownloadTimeout);
+    let contents;
+    try {
+        const response = await fetchRemoteAsset({
+            signal: controller.signal,
+            url,
+        });
+        if (!response.ok) {
+            throw new Error(`Could not download remote asset: ${response.status}`);
+        }
+        contents = await readRemoteAsset({
+            response,
+            abort: () => controller.abort(),
+        });
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === 'AbortError') {
+            throw new Error('Timed out downloading remote asset');
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    const fileType = (0, studio_shared_1.detectFileType)(contents);
+    if (!(0, studio_shared_1.isImageFileType)(fileType)) {
+        throw new Error('Remote asset is not a supported image');
+    }
+    const assetPath = (0, exports.getRemoteAssetFilename)({ fileType, url });
+    const absolutePath = node_path_1.default.join(publicDir, assetPath);
+    const relativeToPublicDir = node_path_1.default.relative(publicDir, absolutePath);
+    if (relativeToPublicDir.startsWith('..') ||
+        node_path_1.default.isAbsolute(relativeToPublicDir)) {
+        throw new Error(`Not allowed to write to ${relativeToPublicDir}`);
+    }
+    const exists = (0, node_fs_1.existsSync)(absolutePath);
+    if (exists) {
+        const stat = (0, node_fs_1.statSync)(absolutePath);
+        if (!stat.isFile()) {
+            throw new Error(`${assetPath} already exists and is not a file`);
+        }
+        if (stat.size !== contents.byteLength) {
+            throw new Error(`File with name ${assetPath} already exists and is different`);
+        }
+    }
+    else {
+        (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(absolutePath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(absolutePath, contents);
+    }
+    const element = {
+        type: 'asset',
+        assetType: fileType.type === 'gif' ? 'gif' : 'image',
+        src: assetPath,
+        dimensions: fileType.dimensions,
+    };
+    return {
+        assetPath,
+        sizeInBytes: contents.byteLength,
+        created: !exists,
+        element,
+    };
+};
+exports.downloadRemoteAssetHandler = downloadRemoteAssetHandler;

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

@@ -17,12 +17,38 @@ const validateElement = (element) => {
     if (element.type === 'solid') {
         validateDimension('width', element.width);
         validateDimension('height', element.height);
+        return;
     }
+    if (element.type === 'asset') {
+        if (!element.src || element.src.includes('\\')) {
+            throw new Error('Asset path must be a static file path');
+        }
+        if (element.dimensions) {
+            validateDimension('width', element.dimensions.width);
+            validateDimension('height', element.dimensions.height);
+        }
+        return;
+    }
+    throw new Error('Unsupported element type');
 };
 const getElementLabel = (element) => {
     if (element.type === 'solid') {
         return '<Solid>';
     }
+    if (element.type === 'asset') {
+        if (element.assetType === 'image') {
+            return '<Img>';
+        }
+        if (element.assetType === 'video') {
+            return '<Video>';
+        }
+        if (element.assetType === 'gif') {
+            return '<Gif>';
+        }
+        if (element.assetType === 'audio') {
+            return '<Audio>';
+        }
+    }
     throw new Error('Unsupported element type');
 };
 const insertJsxElementHandler = ({ input: { compositionFile, compositionId, element }, remotionRoot, logLevel, }) => (0, save_props_mutex_1.withSavePropsLock)(async () => {

package/dist/preview-server/routes/log-studio-error.d.ts

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

package/dist/preview-server/routes/log-studio-error.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logStudioErrorHandler = void 0;
+const renderer_1 = require("@remotion/renderer");
+const { chalk, isColorSupported } = renderer_1.RenderInternals;
+const coerceString = (value) => {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+};
+const formatFrame = (frame) => {
+    const codeFrame = renderer_1.RenderInternals.formatStackFrameCodeFrame(frame);
+    if (codeFrame !== null) {
+        const fileName = renderer_1.RenderInternals.makeStackFrameFileName(frame);
+        const header = fileName ? `at ${chalk.underline(fileName)}` : 'at';
+        return `${header}\n${codeFrame}`;
+    }
+    return renderer_1.RenderInternals.formatStackFrameLocationLine(frame);
+};
+const formatSymbolicatedStack = (name, message, frames) => {
+    const label = name !== null && name !== void 0 ? name : 'Error';
+    const firstLine = isColorSupported()
+        ? `${chalk.bgRed(chalk.white(` ${label} `))} ${message}`
+        : `${label}: ${message}`;
+    const lines = [firstLine];
+    for (const frame of frames) {
+        const formatted = formatFrame(frame);
+        if (formatted === null) {
+            continue;
+        }
+        lines.push('');
+        lines.push(formatted);
+    }
+    return lines.join('\n');
+};
+const logStudioErrorHandler = ({ input, logLevel }) => {
+    var _a;
+    const name = coerceString(input.name);
+    const message = (_a = coerceString(input.message)) !== null && _a !== void 0 ? _a : 'Unknown Studio error';
+    const symbolicatedStackFrames = input.symbolicatedStackFrames && input.symbolicatedStackFrames.length > 0
+        ? input.symbolicatedStackFrames
+        : null;
+    let output;
+    if (symbolicatedStackFrames) {
+        output = formatSymbolicatedStack(name, message, symbolicatedStackFrames);
+    }
+    else {
+        const stack = coerceString(input.stack);
+        const headline = name ? `${name}: ${message}` : message;
+        output = stack
+            ? stack.startsWith(headline)
+                ? stack
+                : `${headline}\n${stack}`
+            : headline;
+    }
+    renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, chalk.red('An error occurred in the Studio:'));
+    renderer_1.RenderInternals.Log.error({ indent: false, logLevel }, output);
+    return Promise.resolve({});
+};
+exports.logStudioErrorHandler = logStudioErrorHandler;

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

@@ -0,0 +1,7 @@
+import type { MoveKeyframesRequest, MoveKeyframesResponse } from '@remotion/studio-shared';
+import type { ApiHandler } from '../api-types';
+export declare const moveKeyframes: ({ sequenceKeyframes, effectKeyframes, clientId, remotionRoot, logLevel, }: MoveKeyframesRequest & {
+    remotionRoot: string;
+    logLevel: "error" | "info" | "trace" | "verbose" | "warn";
+}) => Promise<void>;
+export declare const moveKeyframesHandler: ApiHandler<MoveKeyframesRequest, MoveKeyframesResponse>;

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

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveKeyframesHandler = exports.moveKeyframes = void 0;
+const node_fs_1 = require("node:fs");
+const renderer_1 = require("@remotion/renderer");
+const update_keyframes_1 = require("../../codemods/update-keyframes/update-keyframes");
+const file_watcher_1 = require("../../file-watcher");
+const resolve_file_inside_project_1 = require("../../helpers/resolve-file-inside-project");
+const undo_stack_1 = require("../undo-stack");
+const watch_ignore_next_change_1 = require("../watch-ignore-next-change");
+const log_effect_update_1 = require("./log-updates/log-effect-update");
+const log_update_1 = require("./log-updates/log-update");
+const save_props_mutex_1 = require("./save-props-mutex");
+const groupBy = (items, getKey) => {
+    var _a;
+    const groups = new Map();
+    for (const item of items) {
+        const key = getKey(item);
+        const group = (_a = groups.get(key)) !== null && _a !== void 0 ? _a : [];
+        group.push(item);
+        groups.set(key, group);
+    }
+    return [...groups.values()];
+};
+const getBatchDescription = ({ totalKeyframes, firstKeyframe, }) => {
+    if (totalKeyframes === 1) {
+        return {
+            undoMessage: `↩️  ${firstKeyframe.key} keyframe moved back to frame ${firstKeyframe.fromFrame}`,
+            redoMessage: `↪️  ${firstKeyframe.key} keyframe moved to frame ${firstKeyframe.toFrame}`,
+        };
+    }
+    return {
+        undoMessage: `↩️  ${totalKeyframes} keyframes moved back`,
+        redoMessage: `↪️  ${totalKeyframes} keyframes moved`,
+    };
+};
+const moveKeyframes = async ({ sequenceKeyframes, effectKeyframes, clientId, remotionRoot, logLevel, }) => {
+    var _a, _b;
+    const totalKeyframes = sequenceKeyframes.length + effectKeyframes.length;
+    if (totalKeyframes === 0) {
+        throw new Error('No keyframes were specified for moving');
+    }
+    const fileGroups = new Map();
+    for (const [index, keyframe] of sequenceKeyframes.entries()) {
+        const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName: keyframe.fileName,
+            action: 'modify',
+        });
+        const group = (_a = fileGroups.get(absolutePath)) !== null && _a !== void 0 ? _a : {
+            fileRelativeToRoot,
+            sequenceKeyframes: [],
+            effectKeyframes: [],
+        };
+        group.sequenceKeyframes.push({
+            ...keyframe,
+            index,
+            absolutePath,
+            fileRelativeToRoot,
+        });
+        fileGroups.set(absolutePath, group);
+    }
+    for (const [index, keyframe] of effectKeyframes.entries()) {
+        const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
+            remotionRoot,
+            fileName: keyframe.fileName,
+            action: 'modify',
+        });
+        const group = (_b = fileGroups.get(absolutePath)) !== null && _b !== void 0 ? _b : {
+            fileRelativeToRoot,
+            sequenceKeyframes: [],
+            effectKeyframes: [],
+        };
+        group.effectKeyframes.push({
+            ...keyframe,
+            index,
+            absolutePath,
+            fileRelativeToRoot,
+        });
+        fileGroups.set(absolutePath, group);
+    }
+    const snapshots = [];
+    const sequenceLogs = [];
+    const effectLogs = [];
+    for (const [absolutePath, group] of fileGroups) {
+        const fileContents = (0, node_fs_1.readFileSync)(absolutePath, 'utf-8');
+        let output = fileContents;
+        let firstLogLine = Number.POSITIVE_INFINITY;
+        for (const keyframeGroup of groupBy(group.sequenceKeyframes, (keyframe) => JSON.stringify(keyframe.nodePath.nodePath))) {
+            const [firstSequenceKeyframe] = keyframeGroup;
+            if (!firstSequenceKeyframe) {
+                continue;
+            }
+            const updates = groupBy(keyframeGroup, (keyframe) => keyframe.key).map((keyframes) => {
+                const [firstMove] = keyframes;
+                if (!firstMove) {
+                    throw new Error('Expected keyframe');
+                }
+                return {
+                    key: firstMove.key,
+                    operation: {
+                        type: 'move',
+                        moves: keyframes.map((keyframe) => ({
+                            fromFrame: keyframe.fromFrame,
+                            toFrame: keyframe.toFrame,
+                        })),
+                    },
+                };
+            });
+            const result = await (0, update_keyframes_1.updateSequenceKeyframes)({
+                input: output,
+                nodePath: firstSequenceKeyframe.nodePath.nodePath,
+                schema: firstSequenceKeyframe.schema,
+                updates,
+            });
+            output = result.output;
+            firstLogLine = Math.min(firstLogLine, result.logLine);
+            for (const [updateIndex, update] of updates.entries()) {
+                sequenceLogs.push({
+                    fileRelativeToRoot: firstSequenceKeyframe.fileRelativeToRoot,
+                    line: result.logLine,
+                    key: update.key,
+                    oldValueString: result.oldValueStrings[updateIndex],
+                    newValueString: result.newValueStrings[updateIndex],
+                    formatted: result.formatted,
+                });
+            }
+        }
+        for (const keyframeGroup of groupBy(group.effectKeyframes, (keyframe) => `${JSON.stringify(keyframe.sequenceNodePath.nodePath)}:${keyframe.effectIndex}`)) {
+            const [firstEffectKeyframe] = keyframeGroup;
+            if (!firstEffectKeyframe) {
+                continue;
+            }
+            const updates = groupBy(keyframeGroup, (keyframe) => keyframe.key).map((keyframes) => {
+                const [firstMove] = keyframes;
+                if (!firstMove) {
+                    throw new Error('Expected keyframe');
+                }
+                return {
+                    key: firstMove.key,
+                    operation: {
+                        type: 'move',
+                        moves: keyframes.map((keyframe) => ({
+                            fromFrame: keyframe.fromFrame,
+                            toFrame: keyframe.toFrame,
+                        })),
+                    },
+                };
+            });
+            const result = await (0, update_keyframes_1.updateEffectKeyframes)({
+                input: output,
+                sequenceNodePath: firstEffectKeyframe.sequenceNodePath.nodePath,
+                effectIndex: firstEffectKeyframe.effectIndex,
+                schema: firstEffectKeyframe.schema,
+                updates,
+            });
+            output = result.output;
+            firstLogLine = Math.min(firstLogLine, result.logLine);
+            for (const [updateIndex, update] of updates.entries()) {
+                effectLogs.push({
+                    fileRelativeToRoot: firstEffectKeyframe.fileRelativeToRoot,
+                    line: result.logLine,
+                    effectName: result.effectCallee,
+                    propKey: update.key,
+                    oldValueString: result.oldValueStrings[updateIndex],
+                    newValueString: result.newValueStrings[updateIndex],
+                    formatted: result.formatted,
+                });
+            }
+        }
+        snapshots.push({
+            filePath: absolutePath,
+            oldContents: fileContents,
+            newContents: output,
+            logLine: Number.isFinite(firstLogLine) ? firstLogLine : 1,
+        });
+    }
+    const [firstKeyframe] = sequenceKeyframes.length > 0 ? sequenceKeyframes : effectKeyframes;
+    if (!firstKeyframe) {
+        throw new Error('No keyframes were specified for moving');
+    }
+    (0, undo_stack_1.pushTransactionToUndoStack)({
+        snapshots,
+        logLevel,
+        remotionRoot,
+        description: getBatchDescription({ totalKeyframes, firstKeyframe }),
+        entryType: sequenceKeyframes.length > 0 && effectKeyframes.length > 0
+            ? 'keyframe-delete'
+            : sequenceKeyframes.length > 0
+                ? 'sequence-props'
+                : 'effect-props',
+        suppressHmrOnFileRestore: true,
+    });
+    for (const snapshot of snapshots) {
+        (0, undo_stack_1.suppressUndoStackInvalidation)(snapshot.filePath);
+        (0, watch_ignore_next_change_1.suppressBundlerUpdateForFile)(snapshot.filePath);
+        (0, file_watcher_1.writeFileAndNotifyFileWatchers)(snapshot.filePath, snapshot.newContents, clientId);
+    }
+    for (const log of sequenceLogs) {
+        (0, log_update_1.logUpdate)({
+            fileRelativeToRoot: log.fileRelativeToRoot,
+            line: log.line,
+            key: log.key,
+            oldValueString: log.oldValueString,
+            newValueString: log.newValueString,
+            defaultValueString: null,
+            formatted: log.formatted,
+            logLevel,
+            removedProps: [],
+            addedProps: [],
+        });
+    }
+    for (const log of effectLogs) {
+        (0, log_effect_update_1.logEffectUpdate)({
+            fileRelativeToRoot: log.fileRelativeToRoot,
+            line: log.line,
+            effectName: log.effectName,
+            propKey: log.propKey,
+            oldValueString: log.oldValueString,
+            newValueString: log.newValueString,
+            defaultValueString: null,
+            formatted: log.formatted,
+            logLevel,
+            removedProps: [],
+            addedProps: [],
+        });
+    }
+    (0, undo_stack_1.printUndoHint)(logLevel);
+};
+exports.moveKeyframes = moveKeyframes;
+const moveKeyframesHandler = ({ input: { sequenceKeyframes, effectKeyframes, clientId }, remotionRoot, logLevel, }) => (0, save_props_mutex_1.withSavePropsLock)(async () => {
+    renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[move-keyframes] Received request to move ${sequenceKeyframes.length + effectKeyframes.length} keyframe(s)`);
+    await (0, exports.moveKeyframes)({
+        sequenceKeyframes,
+        effectKeyframes,
+        clientId,
+        remotionRoot,
+        logLevel,
+    });
+    return { success: true };
+});
+exports.moveKeyframesHandler = moveKeyframesHandler;

package/dist/preview-server/routes/paste-effects.d.ts

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