@remotion/studio-server 4.0.508 → 4.0.510

package/dist/canvas-capture/generate-canvas-capture-composition.d.ts

@@ -0,0 +1,14 @@
+import type { CanvasCaptureData } from '@remotion/studio-shared';
+export declare const generateCanvasCaptureComposition: ({ componentName, compositionId, data, durationInFrames, fps, height, keyframeFps, videoFileName, videoHeight, videoWidth, width, }: {
+    readonly componentName: string;
+    readonly compositionId: string;
+    readonly data: CanvasCaptureData;
+    readonly durationInFrames: number;
+    readonly fps: number;
+    readonly height: number;
+    readonly keyframeFps: number;
+    readonly videoFileName: string;
+    readonly videoHeight: number;
+    readonly videoWidth: number;
+    readonly width: number;
+}) => Promise<string>;

package/dist/canvas-capture/generate-canvas-capture-composition.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCanvasCaptureComposition = void 0;
+const duplicate_composition_1 = require("../codemods/duplicate-composition");
+const customCursorRegex = /^\s*url\(/;
+const collapseMouseMovementsByFrame = ({ data, keyframeFps, }) => {
+    const movements = [];
+    for (const movement of data.mouseMovements) {
+        if (movement.canvasX === null || movement.canvasY === null) {
+            continue;
+        }
+        const framedMovement = {
+            ...movement,
+            frame: Math.ceil(movement.timeInSeconds * keyframeFps),
+        };
+        const previous = movements.at(-1);
+        if ((previous === null || previous === void 0 ? void 0 : previous.frame) === framedMovement.frame) {
+            movements[movements.length - 1] = framedMovement;
+        }
+        else {
+            movements.push(framedMovement);
+        }
+    }
+    return movements;
+};
+const getCursorName = (cursor) => {
+    var _a;
+    if (customCursorRegex.test(cursor)) {
+        return 'custom';
+    }
+    return ((_a = cursor.split(',').at(-1)) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase()) || 'default';
+};
+const serialize = (value) => JSON.stringify(value);
+const generateCanvasCaptureComposition = ({ componentName, compositionId, data, durationInFrames, fps, height, keyframeFps, videoFileName, videoHeight, videoWidth, width, }) => {
+    var _a;
+    const movements = collapseMouseMovementsByFrame({ data, keyframeFps });
+    if (movements.length === 0) {
+        throw new Error('The Canvas Capture does not contain cursor movements');
+    }
+    const cursorKeyframes = movements.reduce((keyframes, movement) => {
+        var _a;
+        const value = getCursorName(movement.cursor);
+        if (((_a = keyframes.at(-1)) === null || _a === void 0 ? void 0 : _a.value) !== value) {
+            keyframes.push({ frame: movement.frame, value });
+        }
+        return keyframes;
+    }, []);
+    const positionKeyframes = [];
+    for (const movement of movements) {
+        const previous = positionKeyframes.at(-1);
+        if (previous !== undefined && movement.frame - previous.frame > 1) {
+            positionKeyframes.push({
+                frame: movement.frame - 1,
+                value: previous.value,
+            });
+        }
+        positionKeyframes.push({
+            frame: movement.frame,
+            value: `${movement.canvasX}px ${movement.canvasY}px`,
+        });
+    }
+    const scaleKeyframes = [
+        { frame: 0, value: data.captureMetadata.density },
+        ...data.pointerClicks.map((click) => ({
+            frame: Math.ceil(click.timeInSeconds * keyframeFps),
+            value: click.type === 'pointer-down'
+                ? data.captureMetadata.density * 0.9
+                : data.captureMetadata.density,
+        })),
+    ].reduce((keyframes, keyframe) => {
+        var _a, _b;
+        if (((_a = keyframes.at(-1)) === null || _a === void 0 ? void 0 : _a.frame) === keyframe.frame) {
+            keyframes[keyframes.length - 1] = keyframe;
+        }
+        else if (((_b = keyframes.at(-1)) === null || _b === void 0 ? void 0 : _b.value) !== keyframe.value) {
+            keyframes.push(keyframe);
+        }
+        return keyframes;
+    }, []);
+    const customCursor = (_a = movements.find((movement) => customCursorRegex.test(movement.cursor))) === null || _a === void 0 ? void 0 : _a.cursor;
+    const cursorProp = cursorKeyframes.length === 1
+        ? `cursor=${serialize(cursorKeyframes[0].value)}`
+        : `cursor={interpolate(
+					frame,
+					${serialize(cursorKeyframes.map((keyframe) => keyframe.frame))},
+					${serialize(cursorKeyframes.map((keyframe) => keyframe.value))},
+					{
+						easing: Easing.step1,
+						extrapolateLeft: 'clamp',
+						extrapolateRight: 'clamp',
+					},
+				)}`;
+    const scale = scaleKeyframes.length === 1
+        ? serialize(scaleKeyframes[0].value)
+        : `interpolate(
+						frame,
+						${serialize(scaleKeyframes.map((keyframe) => keyframe.frame))},
+						${serialize(scaleKeyframes.map((keyframe) => keyframe.value))},
+						{
+							easing: Easing.step1,
+							extrapolateLeft: 'clamp',
+							extrapolateRight: 'clamp',
+						},
+					)`;
+    const translate = positionKeyframes.length === 1
+        ? serialize(positionKeyframes[0].value)
+        : `interpolate(
+						frame,
+						${serialize(positionKeyframes.map((keyframe) => keyframe.frame))},
+						${serialize(positionKeyframes.map((keyframe) => keyframe.value))},
+						{
+							extrapolateLeft: 'clamp',
+							extrapolateRight: 'clamp',
+						},
+					)`;
+    const previewComponentName = componentName.endsWith('Composition')
+        ? `${componentName.slice(0, -'Composition'.length)}Preview`
+        : `${componentName}Preview`;
+    return (0, duplicate_composition_1.formatOutput)(`import {MacOSCursor} from '@remotion/mac-cursors';
+import {Video} from '@remotion/media';
+import {
+	AbsoluteFill,
+	Composition,
+	Easing,
+	interpolate,
+	staticFile,
+	useCurrentFrame,
+} from 'remotion';
+
+export const ${previewComponentName} = () => {
+	const frame = useCurrentFrame();
+
+	return (
+		<AbsoluteFill
+			style={{
+				width: ${videoWidth},
+				height: ${videoHeight},
+			}}
+		>
+			<Video
+				src={staticFile(${serialize(videoFileName)})}
+				style={{
+					position: 'absolute',
+				}}
+			/>
+			<MacOSCursor
+				${cursorProp}
+${customCursor === undefined ? '' : `\t\t\t\tcustomCursor={${serialize(customCursor)}}\n`}				style={{
+					position: 'absolute',
+					left: 0,
+					top: 0,
+					scale: ${scale},
+					translate: ${translate},
+				}}
+			/>
+		</AbsoluteFill>
+	);
+};
+
+export const ${componentName} = () => {
+	return (
+		<Composition
+			id=${serialize(compositionId)}
+			component={${previewComponentName}}
+			width={${width}}
+			height={${height}}
+			fps={${fps}}
+			durationInFrames={${durationInFrames}}
+		/>
+	);
+};
+`);
+};
+exports.generateCanvasCaptureComposition = generateCanvasCaptureComposition;

package/dist/codemods/delete-jsx-node.js

@@ -316,7 +316,7 @@ const deleteJsxNodes = async ({ input, nodePaths, prettierConfigOverride, }) =>
         input: finalFile,
         prettierConfigOverride,
     });
-    const nodePathRemappings = (0, get_node_path_remappings_1.getNodePathRemappings)({
+    const { nodePathRemappings } = (0, get_node_path_remappings_1.getNodePathRemappings)({
         ast,
         captured: capturedNodePaths,
         output,

package/dist/codemods/duplicate-composition.js

@@ -81,12 +81,14 @@ const parseAndApplyCodemod = ({ input, codeMod, }) => {
         });
     }
     if (codeMod.type === 'new-composition') {
-        (0, imports_1.ensureNamedImport)({
-            ast: newAst,
-            importedName: 'Composition',
-            sourcePath: 'remotion',
-            localName: 'Composition',
-        });
+        if (codeMod.canvasCapture === null) {
+            (0, imports_1.ensureNamedImport)({
+                ast: newAst,
+                importedName: 'Composition',
+                sourcePath: 'remotion',
+                localName: 'Composition',
+            });
+        }
         (0, imports_1.ensureNamedImport)({
             ast: newAst,
             importedName: codeMod.componentName,

package/dist/codemods/duplicate-jsx-node.js

@@ -303,7 +303,7 @@ const duplicateJsxNode = async ({ input, nodePath, prettierConfigOverride, }) =>
         input: finalFile,
         prettierConfigOverride,
     });
-    const nodePathRemappings = (0, get_node_path_remappings_1.getNodePathRemappings)({
+    const { nodePathRemappings } = (0, get_node_path_remappings_1.getNodePathRemappings)({
         ast,
         captured: capturedNodePaths,
         output,

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

@@ -10,4 +10,7 @@ export declare const getNodePathRemappings: ({ ast, captured, output, }: {
     ast: File;
     captured: CapturedJsxNodePath[];
     output: string;
-}) => SequenceNodePathRemapping[];
+}) => {
+    nodePathRemappings: SequenceNodePathRemapping[];
+    finalNodePathByNode: Map<JSXOpeningElement, SequenceNodePath>;
+};

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

@@ -74,7 +74,7 @@ const getNodePathRemappings = ({ ast, captured, output, }) => {
     for (let i = 0; i < nodesAfterMutation.length; i++) {
         finalNodePathByNode.set(nodesAfterMutation[i], finalNodePaths[i]);
     }
-    return captured.flatMap(({ node, nodePath }) => {
+    const nodePathRemappings = captured.flatMap(({ node, nodePath }) => {
         var _a;
         const newNodePath = (_a = finalNodePathByNode.get(node)) !== null && _a !== void 0 ? _a : null;
         if (newNodePath !== null &&
@@ -83,5 +83,6 @@ const getNodePathRemappings = ({ ast, captured, output, }) => {
         }
         return [{ oldNodePath: nodePath, newNodePath }];
     });
+    return { finalNodePathByNode, nodePathRemappings };
 };
 exports.getNodePathRemappings = getNodePathRemappings;

package/dist/codemods/recast-mods.js

@@ -164,6 +164,19 @@ const jsxAttributeWithExpression = (name, expression) => ({
     },
 });
 const newCompositionElement = (transformation) => {
+    if (transformation.canvasCapture !== null) {
+        return {
+            type: 'JSXElement',
+            openingElement: {
+                type: 'JSXOpeningElement',
+                name: jsxId(transformation.componentName),
+                attributes: [],
+                selfClosing: true,
+            },
+            closingElement: null,
+            children: [],
+        };
+    }
     return {
         type: 'JSXElement',
         openingElement: {

package/dist/codemods/reorder-sequence.js

@@ -101,7 +101,7 @@ const reorderSequence = async ({ input, sourceNodePath, targetNodePath, position
         input: finalFile,
         prettierConfigOverride,
     });
-    const nodePathRemappings = (0, get_node_path_remappings_1.getNodePathRemappings)({
+    const { nodePathRemappings } = (0, get_node_path_remappings_1.getNodePathRemappings)({
         ast,
         captured: capturedNodePaths,
         output,

package/dist/codemods/split-jsx-sequence.d.ts

@@ -1,10 +1,9 @@
-import type { SequenceNodePathRemapping } from '@remotion/studio-shared';
+import { type SequenceNodePathRemapping } from '@remotion/studio-shared';
 import type { SequenceNodePath } from 'remotion';
-export declare const getSplitUnsupportedSequenceTagReason: (tagName: string) => string | null;
-export declare const getIsSplittableSequenceTag: (tagName: string) => boolean;
-export declare const splitJsxSequence: ({ input, nodePath, splitFrame, prettierConfigOverride, }: {
+export declare const splitJsxSequence: ({ input, nodePath, sequenceKeys, splitFrame, prettierConfigOverride, }: {
     input: string;
     nodePath: SequenceNodePath;
+    sequenceKeys: string[];
     splitFrame: number;
     prettierConfigOverride?: Record<string, unknown> | null | undefined;
 }) => Promise<{

package/dist/codemods/split-jsx-sequence.js

@@ -33,8 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitJsxSequence = exports.getIsSplittableSequenceTag = exports.getSplitUnsupportedSequenceTagReason = void 0;
+exports.splitJsxSequence = void 0;
 const types_1 = require("@babel/types");
+const studio_shared_1 = require("@remotion/studio-shared");
 const recast = __importStar(require("recast"));
 const delete_jsx_node_1 = require("./delete-jsx-node");
 const format_file_content_1 = require("./format-file-content");
@@ -172,38 +173,6 @@ const orderTimingAttributes = (element) => {
     const insertionIndex = Math.min(firstTimingIndex, otherAttributes.length);
     attributes.splice(0, attributes.length, ...otherAttributes.slice(0, insertionIndex), ...orderedTimingAttributes, ...otherAttributes.slice(insertionIndex));
 };
-const splittableSequenceTags = new Set([
-    'AnimatedImage',
-    'Arrow',
-    'Audio',
-    'Callout',
-    'CanvasImage',
-    'Circle',
-    'Ellipse',
-    'Gif',
-    'Heart',
-    'Html5Audio',
-    'Html5Video',
-    'HtmlInCanvas',
-    'Img',
-    'OffthreadVideo',
-    'Pie',
-    'Polygon',
-    'Rect',
-    'RemotionRiveCanvas',
-    'Sequence',
-    'Solid',
-    'Spark',
-    'Star',
-    'Starburst',
-    'Triangle',
-    'Video',
-]);
-const unsupportedSequenceTags = new Set([
-    'Series.Sequence',
-    'TransitionSeries.Overlay',
-    'TransitionSeries.Sequence',
-]);
 const jsxMemberNameToString = (name) => {
     if (name.type === 'JSXIdentifier') {
         return name.name;
@@ -216,25 +185,6 @@ const jsxNameToString = (name) => {
     }
     return jsxMemberNameToString(name);
 };
-const getSplitUnsupportedSequenceTagReason = (tagName) => {
-    if (tagName === 'Series.Sequence' ||
-        tagName === 'TransitionSeries.Sequence' ||
-        tagName === 'TransitionSeries.Overlay') {
-        return `<${tagName}> cannot be split from source`;
-    }
-    return null;
-};
-exports.getSplitUnsupportedSequenceTagReason = getSplitUnsupportedSequenceTagReason;
-const getIsSplittableSequenceTag = (tagName) => {
-    if (unsupportedSequenceTags.has(tagName)) {
-        return false;
-    }
-    if (tagName.startsWith('Interactive.')) {
-        return true;
-    }
-    return splittableSequenceTags.has(tagName);
-};
-exports.getIsSplittableSequenceTag = getIsSplittableSequenceTag;
 const getSplittableSequenceTagName = (element) => {
     return jsxNameToString(element.openingElement.name);
 };
@@ -269,7 +219,7 @@ const insertAfter = (parentNode, node, clone) => {
     }
     return false;
 };
-const splitJsxSequence = async ({ input, nodePath, splitFrame, prettierConfigOverride, }) => {
+const splitJsxSequence = async ({ input, nodePath, sequenceKeys, splitFrame, prettierConfigOverride, }) => {
     var _a, _b;
     var _c, _d;
     if (!Number.isInteger(splitFrame)) {
@@ -283,12 +233,8 @@ const splitJsxSequence = async ({ input, nodePath, splitFrame, prettierConfigOve
     }
     const jsxElement = jsxPath.node;
     const tagName = getSplittableSequenceTagName(jsxElement);
-    const unsupportedReason = (0, exports.getSplitUnsupportedSequenceTagReason)(tagName);
-    if (unsupportedReason) {
-        throw new Error(unsupportedReason);
-    }
-    if (!(0, exports.getIsSplittableSequenceTag)(tagName)) {
-        throw new Error(`<${tagName}> does not support sequence timing props and cannot be split`);
+    if (!(0, studio_shared_1.hasSequenceTimingTraits)(sequenceKeys)) {
+        throw new Error(`<${tagName}> cannot be split`);
     }
     const timing = readSequenceTiming(jsxElement);
     const finiteEnd = timing.durationInFrames === Infinity
@@ -342,7 +288,7 @@ const splitJsxSequence = async ({ input, nodePath, splitFrame, prettierConfigOve
         input: finalFile,
         prettierConfigOverride,
     });
-    const nodePathRemappings = (0, get_node_path_remappings_1.getNodePathRemappings)({
+    const { nodePathRemappings } = (0, get_node_path_remappings_1.getNodePathRemappings)({
         ast,
         captured: capturedNodePaths,
         output,

package/dist/codemods/update-keyframes/update-keyframes.js

@@ -334,18 +334,16 @@ const getInlineOptionsFromExtraArgs = (extraArgs) => {
     }
     return existingOptions;
 };
-const normalizeEasingAfterAddingKeyframe = ({ extraArgs, previousSegmentCount, nextSegmentCount, insertedKeyframeIndex, nextKeyframeCount, }) => {
-    const options = getInlineOptionsFromExtraArgs(extraArgs);
+const normalizeEasingAfterAddingKeyframe = ({ extraArgs, previousSegmentCount, nextSegmentCount, insertedKeyframeIndex, nextKeyframeCount, defaultEasing, }) => {
+    var _a, _b;
+    const options = (_a = getInlineOptionsFromExtraArgs(extraArgs)) !== null && _a !== void 0 ? _a : (extraArgs.length === 0 ? createEmptyOptionsExpression() : null);
     if (!options) {
         return { extraArgs, needsEasingImport: false };
     }
-    const easing = getExistingEasingArrayOrNull({
+    const easing = (_b = getExistingEasingArrayOrNull({
         options,
         segmentCount: previousSegmentCount,
-    });
-    if (easing === null) {
-        return { extraArgs, needsEasingImport: false };
-    }
+    })) !== null && _b !== void 0 ? _b : Array.from({ length: previousSegmentCount }, () => defaultEasing);
     if (easing.length < nextSegmentCount) {
         const isSplittingExistingSegment = insertedKeyframeIndex > 0 &&
             insertedKeyframeIndex < nextKeyframeCount - 1;
@@ -353,15 +351,16 @@ const normalizeEasingAfterAddingKeyframe = ({ extraArgs, previousSegmentCount, n
             ? Math.min(insertedKeyframeIndex - 1, easing.length - 1)
             : null;
         easing.splice(insertedKeyframeIndex, 0, easingIndexToDuplicate === null
-            ? studio_shared_1.LINEAR_KEYFRAME_EASING
+            ? defaultEasing
             : easing[easingIndexToDuplicate]);
     }
     while (easing.length < nextSegmentCount) {
-        easing.push(studio_shared_1.LINEAR_KEYFRAME_EASING);
+        easing.push(defaultEasing);
     }
+    const needsEasingImport = setEasingOption({ options, easing });
     return {
         extraArgs: getExtraArgsWithOptions({ extraArgs, options }),
-        needsEasingImport: setEasingOption({ options, easing }),
+        needsEasingImport,
     };
 };
 const getEasingIndexToRemove = ({ removedKeyframeIndex, keyframeCountBeforeRemoval, }) => {
@@ -586,6 +585,9 @@ const addKeyframe = ({ expression, key, frame, value, schema, videoConfigValues,
     const existing = getInterpolationExpression(expression, videoConfigValues);
     const newOutput = (0, update_nested_prop_1.parseValueExpression)(value);
     if (existing) {
+        const defaultEasing = (0, studio_shared_1.isSchemaFieldHoldOnly)({ schema, key })
+            ? studio_shared_1.HOLD_KEYFRAME_EASING
+            : studio_shared_1.LINEAR_KEYFRAME_EASING;
         const existingCalleeName = existing.callee.type === 'Identifier'
             ? existing.callee.name
             : 'interpolate';
@@ -619,6 +621,7 @@ const addKeyframe = ({ expression, key, frame, value, schema, videoConfigValues,
                     .sort((first, second) => first.frame - second.frame)
                     .findIndex((keyframe) => keyframe.frame === frame),
                 nextKeyframeCount: nextKeyframes.length,
+                defaultEasing,
             })
             : { extraArgs: existing.extraArgs, needsEasingImport: false };
         return {
@@ -804,6 +807,10 @@ const applyKeyframeOperation = ({ expression, key, operation, schema, videoConfi
         };
     }
     if (operation.type === 'easing') {
+        if ((0, studio_shared_1.isSchemaFieldHoldOnly)({ schema, key }) &&
+            operation.easing.type !== 'step1') {
+            throw new Error(`Cannot update easing: "${key}" only supports Easing.step1`);
+        }
         const updated = updateKeyframeEasing({
             expression,
             segmentIndex: operation.segmentIndex,

package/dist/helpers/git-client-registry.d.ts

@@ -0,0 +1,30 @@
+import type { GitClientId } from '@remotion/studio-shared';
+type SupportedGitClientPlatform = 'darwin' | 'win32';
+export type InstalledGitClient = {
+    id: GitClientId;
+    name: string;
+    applicationPath: string;
+    platform: SupportedGitClientPlatform;
+};
+export type GitClientDiscoveryContext = {
+    platform: NodeJS.Platform;
+    env: NodeJS.ProcessEnv;
+    homeDirectory: string;
+    pathExists: (filePath: string) => boolean;
+    findMacApplications: (bundleIdentifier: string) => Promise<readonly string[]>;
+    findWindowsApplications: (directory: string) => readonly string[];
+};
+export declare const discoverAvailableGitClients: (context: GitClientDiscoveryContext) => Promise<readonly InstalledGitClient[]>;
+export declare const getAvailableGitClients: () => Promise<readonly InstalledGitClient[]>;
+export declare const getGitClientLaunchInstruction: ({ gitClient, remotionRoot, }: {
+    gitClient: InstalledGitClient;
+    remotionRoot: string;
+}) => {
+    command: string;
+    args: string[];
+};
+export declare const launchGitClient: ({ gitClient, remotionRoot, }: {
+    gitClient: InstalledGitClient;
+    remotionRoot: string;
+}) => Promise<void>;
+export {};

package/dist/helpers/git-client-registry.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchGitClient = exports.getGitClientLaunchInstruction = exports.getAvailableGitClients = exports.discoverAvailableGitClients = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const bundler_1 = require("@remotion/bundler");
+const execFilePromise = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const findMacApplications = async (bundleIdentifier) => {
+    try {
+        const { stdout } = await execFilePromise('mdfind', [
+            `kMDItemCFBundleIdentifier == '${bundleIdentifier}'`,
+        ]);
+        return stdout
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    catch (_a) {
+        return [];
+    }
+};
+const defaultDiscoveryContext = {
+    platform: process.platform,
+    env: process.env,
+    homeDirectory: (0, node_os_1.homedir)(),
+    pathExists: node_fs_1.existsSync,
+    findMacApplications,
+    findWindowsApplications: (directory) => {
+        try {
+            return (0, node_fs_1.readdirSync)(directory, { withFileTypes: true })
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith('app-'))
+                .map((entry) => node_path_1.default.win32.join(directory, entry.name, 'GitHubDesktop.exe'))
+                .sort()
+                .reverse();
+        }
+        catch (_a) {
+            return [];
+        }
+    },
+};
+const discoverAvailableGitClients = async (context) => {
+    if (context.platform === 'darwin') {
+        const discoveredApplications = await context.findMacApplications('com.github.GitHubClient');
+        const applicationPath = [
+            ...new Set([
+                '/Applications/GitHub Desktop.app',
+                node_path_1.default.posix.join(context.homeDirectory, 'Applications/GitHub Desktop.app'),
+                ...discoveredApplications,
+            ]),
+        ].find(context.pathExists);
+        return applicationPath
+            ? [
+                {
+                    applicationPath,
+                    id: 'github-desktop',
+                    name: 'GitHub Desktop',
+                    platform: 'darwin',
+                },
+            ]
+            : [];
+    }
+    if (context.platform === 'win32' && context.env.LOCALAPPDATA) {
+        const installationDirectory = node_path_1.default.win32.join(context.env.LOCALAPPDATA, 'GitHubDesktop');
+        const applicationPath = context
+            .findWindowsApplications(installationDirectory)
+            .find(context.pathExists);
+        return applicationPath
+            ? [
+                {
+                    applicationPath,
+                    id: 'github-desktop',
+                    name: 'GitHub Desktop',
+                    platform: 'win32',
+                },
+            ]
+            : [];
+    }
+    return [];
+};
+exports.discoverAvailableGitClients = discoverAvailableGitClients;
+let availableGitClients = null;
+const getAvailableGitClients = () => {
+    availableGitClients !== null && availableGitClients !== void 0 ? availableGitClients : (availableGitClients = (0, exports.discoverAvailableGitClients)(defaultDiscoveryContext));
+    return availableGitClients;
+};
+exports.getAvailableGitClients = getAvailableGitClients;
+const getGitClientLaunchInstruction = ({ gitClient, remotionRoot, }) => {
+    var _a;
+    const repositoryRoot = (_a = bundler_1.BundlerInternals.findClosestFolderWithItem(remotionRoot, '.git')) !== null && _a !== void 0 ? _a : remotionRoot;
+    return gitClient.platform === 'darwin'
+        ? {
+            command: 'open',
+            args: [
+                '-n',
+                gitClient.applicationPath,
+                '--args',
+                `--cli-open=${repositoryRoot}`,
+            ],
+        }
+        : {
+            command: gitClient.applicationPath,
+            args: [`--cli-open=${repositoryRoot}`],
+        };
+};
+exports.getGitClientLaunchInstruction = getGitClientLaunchInstruction;
+const launchGitClient = async ({ gitClient, remotionRoot, }) => {
+    const { command, args } = (0, exports.getGitClientLaunchInstruction)({
+        gitClient,
+        remotionRoot,
+    });
+    await new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd: remotionRoot,
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.once('error', reject);
+        child.once('spawn', () => {
+            child.unref();
+            resolve();
+        });
+    });
+};
+exports.launchGitClient = launchGitClient;