Add .gitignore to exclude all node packages and lock files

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/api-key.d.ts

@@ -0,0 +1,15 @@
+export declare const apiKeyOption: {
+    name: string;
+    cliFlag: "api-key";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "apiKey";
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (value: string | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/api-key.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiKeyOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let currentApiKey = null;
+const cliFlag = 'api-key';
+exports.apiKeyOption = {
+    name: 'API key',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["API key for sending a usage event using ",
+            jsx_runtime_1.jsx("code", { children: "@remotion/licensing" }),
+            "."] })),
+    ssrName: 'apiKey',
+    docLink: 'https://www.remotion.dev/docs/licensing',
+    type: null,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        return {
+            source: 'default',
+            value: currentApiKey,
+        };
+    },
+    setConfig: (value) => {
+        currentApiKey = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/ask-ai.d.ts

@@ -0,0 +1,15 @@
+export declare const askAIOption: {
+    name: string;
+    cliFlag: "disable-ask-ai";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/ask-ai.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askAIOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let askAIEnabled = true;
+const cliFlag = 'disable-ask-ai';
+exports.askAIOption = {
+    name: 'Disable or Enable the Ask AI option',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "If the Cmd + I shortcut of the Ask AI modal conflicts with your Studio, you can disable it using this." })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/config#setaskaienabled',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            askAIEnabled = false;
+            return {
+                value: askAIEnabled,
+                source: 'cli',
+            };
+        }
+        return {
+            value: askAIEnabled,
+            source: 'config',
+        };
+    },
+    setConfig(value) {
+        askAIEnabled = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/audio-bitrate.d.ts

@@ -0,0 +1,18 @@
+export declare const audioBitrateOption: {
+    name: string;
+    cliFlag: "audio-bitrate";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: string;
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (value: string | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/audio-bitrate.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioBitrateOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'audio-bitrate';
+let audioBitrate = null;
+exports.audioBitrateOption = {
+    name: 'Audio Bitrate',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Specify the target bitrate for the generated video. The syntax for FFmpeg", "'", "s ",
+            jsx_runtime_1.jsx("code", { children: "-b:a" }),
+            " parameter should be used. FFmpeg may encode the video in a way that will not result in the exact audio bitrate specified. Example values: ",
+            jsx_runtime_1.jsx("code", { children: "512K" }),
+            " for 512 kbps, ",
+            jsx_runtime_1.jsx("code", { children: "1M" }),
+            " for 1 Mbps. Default: ",
+            jsx_runtime_1.jsx("code", { children: "320k" })
+        ] })),
+    ssrName: 'audioBitrate',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media#audiobitrate-',
+    type: '0',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (audioBitrate) {
+            return {
+                value: audioBitrate,
+                source: 'config file',
+            };
+        }
+        return {
+            value: null,
+            source: 'default',
+        };
+    },
+    setConfig: (value) => {
+        audioBitrate = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/audio-codec.d.ts

@@ -0,0 +1,52 @@
+import type { Codec } from '../codec';
+export declare const validAudioCodecs: readonly ["pcm-16", "aac", "mp3", "opus"];
+export type AudioCodec = (typeof validAudioCodecs)[number];
+export declare const supportedAudioCodecs: {
+    readonly h264: readonly ["aac", "pcm-16", "mp3"];
+    readonly 'h264-mkv': readonly ["pcm-16", "mp3"];
+    readonly 'h264-ts': readonly ["pcm-16", "aac"];
+    readonly aac: readonly ["aac", "pcm-16"];
+    readonly avi: readonly [];
+    readonly gif: readonly [];
+    readonly h265: readonly ["aac", "pcm-16"];
+    readonly mp3: readonly ["mp3", "pcm-16"];
+    readonly prores: readonly ["aac", "pcm-16"];
+    readonly vp8: readonly ["opus", "pcm-16"];
+    readonly vp9: readonly ["opus", "pcm-16"];
+    readonly wav: readonly ["pcm-16"];
+};
+export declare const mapAudioCodecToFfmpegAudioCodecName: (audioCodec: "aac" | "mp3" | "opus" | "pcm-16") => "libfdk_aac" | "libmp3lame" | "libopus" | "pcm_s16le";
+export declare const defaultAudioCodecs: {
+    [key in Codec]: {
+        [_ in 'compressed' | 'lossless']: (typeof supportedAudioCodecs)[key][number] | null;
+    };
+};
+export declare const getExtensionFromAudioCodec: (audioCodec: "aac" | "mp3" | "opus" | "pcm-16") => "aac" | "mp3" | "opus" | "wav";
+export declare const resolveAudioCodec: ({ codec, setting, preferLossless, separateAudioTo, }: {
+    setting: "aac" | "mp3" | "opus" | "pcm-16" | null;
+    codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
+    preferLossless: boolean;
+    separateAudioTo: string | null;
+}) => "aac" | "mp3" | "opus" | "pcm-16" | null;
+export declare const getDefaultAudioCodec: ({ codec, preferLossless, }: {
+    codec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
+    preferLossless: boolean;
+}) => "aac" | "mp3" | "opus" | "pcm-16" | null;
+export declare const audioCodecOption: {
+    cliFlag: "audio-codec";
+    setConfig: (audioCodec: "aac" | "mp3" | "opus" | "pcm-16" | null) => void;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: "aac" | "mp3" | "opus" | "pcm-16";
+    } | {
+        source: string;
+        value: null;
+    };
+    description: () => string;
+    docLink: string;
+    name: string;
+    ssrName: "audioCodec";
+    type: "aac" | "mp3" | "opus" | "pcm-16";
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/audio-codec.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioCodecOption = exports.getDefaultAudioCodec = exports.resolveAudioCodec = exports.getExtensionFromAudioCodec = exports.defaultAudioCodecs = exports.mapAudioCodecToFfmpegAudioCodecName = exports.supportedAudioCodecs = exports.validAudioCodecs = void 0;
+const separate_audio_1 = require("./separate-audio");
+exports.validAudioCodecs = ['pcm-16', 'aac', 'mp3', 'opus'];
+exports.supportedAudioCodecs = {
+    h264: ['aac', 'pcm-16', 'mp3'],
+    'h264-mkv': ['pcm-16', 'mp3'],
+    'h264-ts': ['pcm-16', 'aac'],
+    aac: ['aac', 'pcm-16'],
+    avi: [],
+    gif: [],
+    h265: ['aac', 'pcm-16'],
+    mp3: ['mp3', 'pcm-16'],
+    prores: ['aac', 'pcm-16'],
+    vp8: ['opus', 'pcm-16'],
+    vp9: ['opus', 'pcm-16'],
+    wav: ['pcm-16'],
+};
+const _satisfies = exports.supportedAudioCodecs;
+if (_satisfies) {
+    // Just for type checking
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const audioCodecNames = [
+    'pcm_s16le',
+    'libfdk_aac',
+    'libmp3lame',
+    'libopus',
+];
+const mapAudioCodecToFfmpegAudioCodecName = (audioCodec) => {
+    if (audioCodec === 'aac') {
+        return 'libfdk_aac';
+    }
+    if (audioCodec === 'mp3') {
+        return 'libmp3lame';
+    }
+    if (audioCodec === 'opus') {
+        return 'libopus';
+    }
+    if (audioCodec === 'pcm-16') {
+        return 'pcm_s16le';
+    }
+    throw new Error('unknown audio codec: ' + audioCodec);
+};
+exports.mapAudioCodecToFfmpegAudioCodecName = mapAudioCodecToFfmpegAudioCodecName;
+const cliFlag = 'audio-codec';
+const ssrName = 'audioCodec';
+exports.defaultAudioCodecs = {
+    'h264-mkv': {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    'h264-ts': {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    aac: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    gif: {
+        lossless: null,
+        compressed: null,
+    },
+    h264: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    h265: {
+        lossless: 'pcm-16',
+        compressed: 'aac',
+    },
+    mp3: {
+        lossless: 'pcm-16',
+        compressed: 'mp3',
+    },
+    prores: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+    vp8: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    vp9: {
+        lossless: 'pcm-16',
+        compressed: 'opus',
+    },
+    wav: {
+        lossless: 'pcm-16',
+        compressed: 'pcm-16',
+    },
+};
+const extensionMap = {
+    aac: 'aac',
+    mp3: 'mp3',
+    opus: 'opus',
+    'pcm-16': 'wav',
+};
+const getExtensionFromAudioCodec = (audioCodec) => {
+    if (extensionMap[audioCodec]) {
+        return extensionMap[audioCodec];
+    }
+    throw new Error(`Unsupported audio codec: ${audioCodec}`);
+};
+exports.getExtensionFromAudioCodec = getExtensionFromAudioCodec;
+const resolveAudioCodec = ({ codec, setting, preferLossless, separateAudioTo, }) => {
+    let derivedFromSeparateAudioToExtension = null;
+    if (separateAudioTo) {
+        const extension = separateAudioTo.split('.').pop();
+        for (const [key, value] of Object.entries(extensionMap)) {
+            if (value === extension) {
+                derivedFromSeparateAudioToExtension = key;
+                if (!exports.supportedAudioCodecs[codec].includes(derivedFromSeparateAudioToExtension) &&
+                    derivedFromSeparateAudioToExtension) {
+                    throw new Error(`The codec is ${codec} but the audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}. The only supported codecs are: ${exports.supportedAudioCodecs[codec].join(', ')}`);
+                }
+            }
+        }
+    }
+    // Explanation: https://github.com/remotion-dev/remotion/issues/1647
+    if (preferLossless) {
+        const selected = (0, exports.getDefaultAudioCodec)({ codec, preferLossless });
+        if (derivedFromSeparateAudioToExtension &&
+            selected !== derivedFromSeparateAudioToExtension) {
+            throw new Error(`The audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from the "Prefer lossless" option (${selected}). Remove any conflicting options.`);
+        }
+        return selected;
+    }
+    if (setting === null) {
+        if (derivedFromSeparateAudioToExtension) {
+            return derivedFromSeparateAudioToExtension;
+        }
+        return (0, exports.getDefaultAudioCodec)({ codec, preferLossless });
+    }
+    if (derivedFromSeparateAudioToExtension !== setting &&
+        derivedFromSeparateAudioToExtension) {
+        throw new Error(`The audio codec derived from --${separate_audio_1.separateAudioOption.cliFlag} is ${derivedFromSeparateAudioToExtension}, but does not match the audio codec derived from your ${exports.audioCodecOption.name} setting (${setting}). Remove any conflicting options.`);
+    }
+    return setting;
+};
+exports.resolveAudioCodec = resolveAudioCodec;
+const getDefaultAudioCodec = ({ codec, preferLossless, }) => {
+    return exports.defaultAudioCodecs[codec][preferLossless ? 'lossless' : 'compressed'];
+};
+exports.getDefaultAudioCodec = getDefaultAudioCodec;
+let _audioCodec = null;
+exports.audioCodecOption = {
+    cliFlag,
+    setConfig: (audioCodec) => {
+        if (audioCodec === null) {
+            _audioCodec = null;
+            return;
+        }
+        if (!exports.validAudioCodecs.includes(audioCodec)) {
+            throw new Error(`Audio codec must be one of the following: ${exports.validAudioCodecs.join(', ')}, but got ${audioCodec}`);
+        }
+        _audioCodec = audioCodec;
+    },
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            const codec = commandLine[cliFlag];
+            if (!exports.validAudioCodecs.includes(commandLine[cliFlag])) {
+                throw new Error(`Audio codec must be one of the following: ${exports.validAudioCodecs.join(', ')}, but got ${codec}`);
+            }
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (_audioCodec !== null) {
+            return {
+                source: 'config',
+                value: _audioCodec,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    description: () => `Set the format of the audio that is embedded in the video. Not all codec and audio codec combinations are supported and certain combinations require a certain file extension and container format. See the table in the docs to see possible combinations.`,
+    docLink: 'https://www.remotion.dev/docs/encoding/#audio-codec',
+    name: 'Audio Codec',
+    ssrName,
+    type: 'aac',
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/beep-on-finish.d.ts

@@ -0,0 +1,15 @@
+export declare const beepOnFinishOption: {
+    name: string;
+    cliFlag: "beep-on-finish";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/beep-on-finish.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beepOnFinishOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let beepOnFinish = false;
+const cliFlag = 'beep-on-finish';
+exports.beepOnFinishOption = {
+    name: 'Beep on finish',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Whether the Remotion Studio tab should beep when the render is finished." })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/config#setbeeponfinish',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (beepOnFinish !== false) {
+            return {
+                value: beepOnFinish,
+                source: 'config',
+            };
+        }
+        return {
+            value: false,
+            source: 'default',
+        };
+    },
+    setConfig(value) {
+        beepOnFinish = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/binaries-directory.d.ts

@@ -0,0 +1,15 @@
+export declare const binariesDirectoryOption: {
+    name: string;
+    cliFlag: "binaries-directory";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "binariesDirectory";
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (value: string | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/binaries-directory.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binariesDirectoryOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'binaries-directory';
+let currentDirectory = null;
+exports.binariesDirectoryOption = {
+    name: 'Binaries Directory',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["The directory where the platform-specific binaries and libraries that Remotion needs are located. Those include an ",
+            jsx_runtime_1.jsx("code", { children: "ffmpeg" }),
+            " and", ' ', jsx_runtime_1.jsx("code", { children: "ffprobe" }),
+            " binary, a Rust binary for various tasks, and various shared libraries. If the value is set to ",
+            jsx_runtime_1.jsx("code", { children: "null" }),
+            ", which is the default, then the path of a platform-specific package located at", ' ', jsx_runtime_1.jsx("code", { children: "node_modules/@remotion/compositor-*" }),
+            " is selected.",
+            jsx_runtime_1.jsx("br", {}),
+            "This option is useful in environments where Remotion is not officially supported to run like bundled serverless functions or Electron."] })),
+    ssrName: 'binariesDirectory',
+    docLink: 'https://www.remotion.dev/docs/renderer',
+    type: '',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentDirectory !== null) {
+            return {
+                source: 'config',
+                value: currentDirectory,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        currentDirectory = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/chrome-mode.d.ts

@@ -0,0 +1,17 @@
+export declare const validChromeModeOptions: readonly ["headless-shell", "chrome-for-testing"];
+export type ChromeMode = (typeof validChromeModeOptions)[number];
+export declare const chromeModeOption: {
+    cliFlag: "chrome-mode";
+    name: string;
+    ssrName: string;
+    description: () => import("react/jsx-runtime").JSX.Element;
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: "chrome-for-testing" | "headless-shell";
+        source: string;
+    };
+    setConfig: (newChromeMode: "chrome-for-testing" | "headless-shell") => void;
+    type: "chrome-for-testing" | "headless-shell";
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/chrome-mode.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chromeModeOption = exports.validChromeModeOptions = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+exports.validChromeModeOptions = [
+    'headless-shell',
+    'chrome-for-testing',
+];
+const cliFlag = 'chrome-mode';
+let configSelection = null;
+exports.chromeModeOption = {
+    cliFlag,
+    name: 'Chrome Mode',
+    ssrName: 'chromeMode',
+    description: () => {
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["One of", ' ', exports.validChromeModeOptions.map((option, i) => (jsx_runtime_1.jsxs("code", { children: [option, i === exports.validChromeModeOptions.length - 1 ? '' : ', '] }, option))), ". Default ",
+                jsx_runtime_1.jsx("code", { children: "headless-shell" }),
+                ".", ' ', jsx_runtime_1.jsxs("a", { href: "https://remotion.dev/docs/miscellaneous/chrome-headless-shell", children: ["Use ",
+                        jsx_runtime_1.jsx("code", { children: "chrome-for-testing" }),
+                        " to take advantage of GPU drivers on Linux."] })
+            ] }));
+    },
+    docLink: 'https://www.remotion.dev/chrome-for-testing',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            if (!exports.validChromeModeOptions.includes(commandLine[cliFlag])) {
+                throw new Error(`Invalid \`--${cliFlag}\` value passed. Accepted values: ${exports.validChromeModeOptions
+                    .map((l) => `'${l}'`)
+                    .join(', ')}.`);
+            }
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (configSelection !== null) {
+            return {
+                value: configSelection,
+                source: 'config',
+            };
+        }
+        return {
+            value: 'headless-shell',
+            source: 'default',
+        };
+    },
+    setConfig: (newChromeMode) => {
+        configSelection = newChromeMode;
+    },
+    type: 'headless-shell',
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/color-space.d.ts

@@ -0,0 +1,19 @@
+export declare const validColorSpaces: readonly ["default", "bt709", "bt2020-ncl"];
+export type ColorSpace = (typeof validColorSpaces)[number];
+export declare const DEFAULT_COLOR_SPACE: "default";
+export declare const colorSpaceOption: {
+    name: string;
+    cliFlag: "color-space";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    docLink: string;
+    ssrName: string;
+    type: "bt2020-ncl" | "bt709" | "default" | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: "bt2020-ncl" | "bt709" | "default";
+    };
+    setConfig: (value: "bt2020-ncl" | "bt709" | "default" | null) => void;
+};
+export declare const validateColorSpace: (option: unknown) => void;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/color-space.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateColorSpace = exports.colorSpaceOption = exports.DEFAULT_COLOR_SPACE = exports.validColorSpaces = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const no_react_1 = require("remotion/no-react");
+const validV4ColorSpaces = ['default', 'bt709', 'bt2020-ncl'];
+const validV5ColorSpaces = ['bt601', 'bt709', 'bt2020-ncl'];
+exports.validColorSpaces = (no_react_1.NoReactInternals.ENABLE_V5_BREAKING_CHANGES
+    ? validV5ColorSpaces
+    : validV4ColorSpaces);
+exports.DEFAULT_COLOR_SPACE = (no_react_1.NoReactInternals.ENABLE_V5_BREAKING_CHANGES ? 'bt709' : 'default');
+let colorSpace = exports.DEFAULT_COLOR_SPACE;
+const cliFlag = 'color-space';
+exports.colorSpaceOption = {
+    name: 'Color space',
+    cliFlag: 'color-space',
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Color space to use for the video. Acceptable values:", ' ', jsx_runtime_1.jsxs("code", { children: ['"', exports.DEFAULT_COLOR_SPACE, '"'] }),
+            "(default since 5.0),", ' ', no_react_1.NoReactInternals.ENABLE_V5_BREAKING_CHANGES ? (jsx_runtime_1.jsxs("code", { children: ['"', "bt601", '"', ', '] })) : (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: [
+                    jsx_runtime_1.jsxs("code", { children: ['"', "bt709", '"'] }), ' ', "(since v4.0.28),", ' '] })), jsx_runtime_1.jsxs("code", { children: ['"', "bt2020-ncl", '"'] }), ' ', "(since v4.0.88),", ' ', jsx_runtime_1.jsxs("code", { children: ['"', "bt2020-cl", '"'] }), ' ', "(since v4.0.88), .",
+            jsx_runtime_1.jsx("br", {}),
+            "For best color accuracy, it is recommended to also use", ' ', jsx_runtime_1.jsxs("code", { children: ['"', "png", '"'] }), ' ', "as the image format to have accurate color transformations throughout.",
+            jsx_runtime_1.jsx("br", {}),
+            "Only since v4.0.83, colorspace conversion is actually performed, previously it would only tag the metadata of the video."] })),
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media#colorspace',
+    ssrName: 'colorSpace',
+    type: exports.DEFAULT_COLOR_SPACE,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (colorSpace !== exports.DEFAULT_COLOR_SPACE) {
+            return {
+                source: 'config',
+                value: colorSpace,
+            };
+        }
+        return {
+            source: 'default',
+            value: exports.DEFAULT_COLOR_SPACE,
+        };
+    },
+    setConfig: (value) => {
+        colorSpace = value !== null && value !== void 0 ? value : exports.DEFAULT_COLOR_SPACE;
+    },
+};
+const validateColorSpace = (option) => {
+    if (exports.validColorSpaces.includes(option)) {
+        return;
+    }
+    throw new Error(`Expected one of ${exports.validColorSpaces.map((c) => `"${c}"`).join(', ')} for ${exports.colorSpaceOption.ssrName} but got "${option}"`);
+};
+exports.validateColorSpace = validateColorSpace;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/crf.d.ts

@@ -0,0 +1,17 @@
+import type { Crf } from '../crf';
+export declare const validateCrf: (newCrf: Crf) => void;
+export declare const crfOption: {
+    name: string;
+    cliFlag: "crf";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: number;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: Crf;
+    };
+    setConfig: (crf: Crf) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/crf.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crfOption = exports.validateCrf = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let currentCrf;
+const validateCrf = (newCrf) => {
+    if (typeof newCrf !== 'number' && newCrf !== undefined) {
+        throw new TypeError('The CRF must be a number or undefined.');
+    }
+};
+exports.validateCrf = validateCrf;
+const cliFlag = 'crf';
+exports.crfOption = {
+    name: 'CRF',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "No matter which codec you end up using, there's always a tradeoff between file size and video quality. You can control it by setting the CRF (Constant Rate Factor). The lower the number, the better the quality, the higher the number, the smaller the file is \u2013 of course at the cost of quality." })),
+    ssrName: 'crf',
+    docLink: 'https://www.remotion.dev/docs/encoding/#controlling-quality-using-the-crf-setting',
+    type: 0,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            (0, exports.validateCrf)(commandLine[cliFlag]);
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentCrf !== null) {
+            return {
+                source: 'config',
+                value: currentCrf,
+            };
+        }
+        return {
+            source: 'default',
+            value: undefined,
+        };
+    },
+    setConfig: (crf) => {
+        (0, exports.validateCrf)(crf);
+        currentCrf = crf;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/cross-site-isolation.d.ts

@@ -0,0 +1,15 @@
+export declare const enableCrossSiteIsolationOption: {
+    name: string;
+    cliFlag: "cross-site-isolation";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/cross-site-isolation.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableCrossSiteIsolationOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let enableCrossSiteIsolation = false;
+const cliFlag = 'cross-site-isolation';
+exports.enableCrossSiteIsolationOption = {
+    name: 'Enable Cross-Site Isolation',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Enable Cross-Site Isolation in the Studio (sets Cross-Origin-Opener-Policy and Cross-Origin-Embedder-Policy HTTP headers, required for", ' ', jsx_runtime_1.jsx("code", { children: "@remotion/whisper-web" }),
+            ")."] })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/config#setenablecrosssiteisolation',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        return {
+            value: enableCrossSiteIsolation,
+            source: 'config',
+        };
+    },
+    setConfig(value) {
+        enableCrossSiteIsolation = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/dark-mode.d.ts

@@ -0,0 +1,15 @@
+export declare const darkModeOption: {
+    name: string;
+    cliFlag: "dark-mode";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: boolean;
+    };
+    setConfig: (value: boolean) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/dark-mode.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.darkModeOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const DEFAULT_VALUE = false;
+let darkMode = DEFAULT_VALUE;
+const cliFlag = 'dark-mode';
+exports.darkModeOption = {
+    name: 'Dark Mode',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Whether Chromium should pretend to be in dark mode by emulating the media feature 'prefers-color-scheme: dark'. Default is", ' ', jsx_runtime_1.jsx("code", { children: String(DEFAULT_VALUE) }),
+            "."] })),
+    ssrName: 'darkMode',
+    docLink: 'https://www.remotion.dev/docs/chromium-flags#--dark-mode',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (darkMode !== DEFAULT_VALUE) {
+            return {
+                source: 'config',
+                value: darkMode,
+            };
+        }
+        return {
+            source: 'default',
+            value: DEFAULT_VALUE,
+        };
+    },
+    setConfig: (value) => {
+        darkMode = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/delete-after.d.ts

@@ -0,0 +1,19 @@
+export type DeleteAfter = '1-day' | '3-days' | '7-days' | '30-days';
+export declare const deleteAfterOption: {
+    name: string;
+    cliFlag: "delete-after";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "deleteAfter";
+    docLink: string;
+    type: DeleteAfter | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: DeleteAfter;
+    } | {
+        source: string;
+        value: null;
+    };
+    setConfig: (value: DeleteAfter | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/delete-after.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteAfterOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'delete-after';
+let deleteAfter = null;
+exports.deleteAfterOption = {
+    name: 'Lambda render expiration',
+    cliFlag,
+    description: () => {
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Automatically delete the render after a certain period. Accepted values are ",
+                jsx_runtime_1.jsx("code", { children: "1-day" }),
+                ", ",
+                jsx_runtime_1.jsx("code", { children: "3-days" }),
+                ", ",
+                jsx_runtime_1.jsx("code", { children: "7-days" }),
+                " and", ' ', jsx_runtime_1.jsx("code", { children: "30-days" }),
+                ".",
+                jsx_runtime_1.jsx("br", {}),
+                " For this to work, your bucket needs to have", ' ', jsx_runtime_1.jsx("a", { href: "/docs/lambda/autodelete", children: "lifecycles enabled" }),
+                "."] }));
+    },
+    ssrName: 'deleteAfter',
+    docLink: 'https://www.remotion.dev/docs/lambda/autodelete',
+    type: '1-day',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (deleteAfter !== null) {
+            return {
+                source: 'config',
+                value: deleteAfter,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        deleteAfter = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/disable-git-source.d.ts

@@ -0,0 +1,15 @@
+export declare const disableGitSourceOption: {
+    cliFlag: string;
+    description: () => string;
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: boolean;
+    };
+    name: string;
+    setConfig: () => never;
+    ssrName: string;
+    type: boolean;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/disable-git-source.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disableGitSourceOption = void 0;
+const DEFAULT = false;
+const cliFlag = 'disable-git-source';
+exports.disableGitSourceOption = {
+    cliFlag,
+    description: () => `Disables the Git Source being connected to the Remotion Studio. Clicking on stack traces and certain menu items will be disabled.`,
+    docLink: 'https://remotion.dev/docs/bundle',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        return {
+            source: 'default',
+            value: DEFAULT,
+        };
+    },
+    name: 'Disable Git source',
+    setConfig: () => {
+        throw new Error('Not implemented');
+    },
+    ssrName: 'disableGitSource',
+    type: false,
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/disallow-parallel-encoding.d.ts

@@ -0,0 +1,15 @@
+export declare const disallowParallelEncodingOption: {
+    name: string;
+    cliFlag: "disallow-parallel-encoding";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/disallow-parallel-encoding.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disallowParallelEncodingOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let disallowParallelEncoding = false;
+const cliFlag = 'disallow-parallel-encoding';
+exports.disallowParallelEncodingOption = {
+    name: 'Disallow parallel encoding',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Disallows the renderer from doing rendering frames and encoding at the same time. This makes the rendering process more memory-efficient, but possibly slower." })),
+    ssrName: 'disallowParallelEncoding',
+    docLink: 'https://www.remotion.dev/docs/config#setdisallowparallelencoding',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (disallowParallelEncoding !== false) {
+            return {
+                value: disallowParallelEncoding,
+                source: 'config',
+            };
+        }
+        return {
+            value: false,
+            source: 'default',
+        };
+    },
+    setConfig(value) {
+        disallowParallelEncoding = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/enable-lambda-insights.d.ts

@@ -0,0 +1,15 @@
+export declare const enableLambdaInsights: {
+    name: string;
+    cliFlag: "enable-lambda-insights";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    setConfig: (value: boolean) => void;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/enable-lambda-insights.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableLambdaInsights = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'enable-lambda-insights';
+let option = false;
+exports.enableLambdaInsights = {
+    name: 'Enable Lambda Insights',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Enable", ' ', jsx_runtime_1.jsx("a", { href: "https://remotion.dev/docs/lambda/insights", children: "Lambda Insights in AWS CloudWatch" }),
+            ". For this to work, you may have to update your role permission."] })),
+    ssrName: 'enableLambdaInsights',
+    docLink: 'https://www.remotion.dev/docs/lambda/insights',
+    type: false,
+    setConfig: (value) => {
+        option = value;
+    },
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (option) {
+            return {
+                value: option,
+                source: 'config',
+            };
+        }
+        return {
+            value: false,
+            source: 'default',
+        };
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/enable-multiprocess-on-linux.d.ts

@@ -0,0 +1,15 @@
+export declare const enableMultiprocessOnLinuxOption: {
+    name: string;
+    cliFlag: "enable-multiprocess-on-linux";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: boolean;
+    };
+    setConfig: (value: boolean) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/enable-multiprocess-on-linux.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableMultiprocessOnLinuxOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const DEFAULT_VALUE = true;
+let multiProcessOnLinux = DEFAULT_VALUE;
+const cliFlag = 'enable-multiprocess-on-linux';
+exports.enableMultiprocessOnLinuxOption = {
+    name: 'Enable Multiprocess on Linux',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Removes the ",
+            jsx_runtime_1.jsx("code", { children: '--single-process' }),
+            " flag that gets passed to Chromium on Linux by default. This will make the render faster because multiple processes can be used, but may cause issues with some Linux distributions or if window server libraries are missing.",
+            jsx_runtime_1.jsx("br", {}),
+            "Default: ",
+            jsx_runtime_1.jsx("code", { children: "false" }),
+            " until v4.0.136, then ",
+            jsx_runtime_1.jsx("code", { children: "true" }),
+            " from v4.0.137 on because newer Chrome versions ", "don't", " allow rendering with the ",
+            jsx_runtime_1.jsx("code", { children: "--single-process" }),
+            " flag. ",
+            jsx_runtime_1.jsx("br", {}),
+            "This flag will be removed in Remotion v5.0."] })),
+    ssrName: 'chromiumOptions.enableMultiprocessOnLinux',
+    docLink: 'https://www.remotion.dev/docs/chromium-flags',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (multiProcessOnLinux !== false) {
+            return {
+                source: 'config',
+                value: multiProcessOnLinux,
+            };
+        }
+        return {
+            source: 'default',
+            value: DEFAULT_VALUE,
+        };
+    },
+    setConfig: (value) => {
+        multiProcessOnLinux = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/encoding-buffer-size.d.ts

@@ -0,0 +1,18 @@
+export declare const encodingBufferSizeOption: {
+    name: string;
+    cliFlag: "buffer-size";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "encodingBufferSize";
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: string;
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (bitrate: string | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/encoding-buffer-size.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodingBufferSizeOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+/**
+ * encodingBufferSize is not a bitrate, but it is a bitrate-related option and get validated like a bitrate.
+ */
+let encodingBufferSize = null;
+const setEncodingBufferSize = (bitrate) => {
+    encodingBufferSize = bitrate;
+};
+const cliFlag = 'buffer-size';
+exports.encodingBufferSizeOption = {
+    name: 'FFmpeg -bufsize flag',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["The value for the ",
+            jsx_runtime_1.jsx("code", { children: "-bufsize" }),
+            " flag of FFmpeg. Should be used in conjunction with the encoding max rate flag."] })),
+    ssrName: 'encodingBufferSize',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media#encodingbuffersize',
+    type: '',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (encodingBufferSize !== null) {
+            return {
+                value: encodingBufferSize,
+                source: 'config',
+            };
+        }
+        return {
+            value: null,
+            source: 'default',
+        };
+    },
+    setConfig: setEncodingBufferSize,
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/encoding-max-rate.d.ts

@@ -0,0 +1,18 @@
+export declare const encodingMaxRateOption: {
+    name: string;
+    cliFlag: "max-rate";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "encodingMaxRate";
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: string;
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (newMaxRate: string | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/encoding-max-rate.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodingMaxRateOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let encodingMaxRate = null;
+const cliFlag = 'max-rate';
+exports.encodingMaxRateOption = {
+    name: 'FFmpeg -maxrate flag',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["The value for the ",
+            jsx_runtime_1.jsx("code", { children: "-maxrate" }),
+            " flag of FFmpeg. Should be used in conjunction with the encoding buffer size flag."] })),
+    ssrName: 'encodingMaxRate',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media#encodingmaxrate',
+    type: '',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (encodingMaxRate !== null) {
+            return {
+                value: encodingMaxRate,
+                source: 'config',
+            };
+        }
+        return {
+            value: null,
+            source: 'default',
+        };
+    },
+    setConfig: (newMaxRate) => {
+        encodingMaxRate = newMaxRate;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/enforce-audio.d.ts

@@ -0,0 +1,18 @@
+export declare const enforceAudioOption: {
+    name: string;
+    cliFlag: "enforce-audio-track";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: true;
+    } | {
+        source: string;
+        value: false;
+    };
+    setConfig: (value: boolean) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/enforce-audio.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceAudioOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const DEFAULT_ENFORCE_AUDIO_TRACK = false;
+let enforceAudioTrackState = DEFAULT_ENFORCE_AUDIO_TRACK;
+const cliFlag = 'enforce-audio-track';
+exports.enforceAudioOption = {
+    name: 'Enforce Audio Track',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Render a silent audio track if there would be none otherwise." })),
+    ssrName: 'enforceAudioTrack',
+    docLink: 'https://www.remotion.dev/docs/config#setenforceaudiotrack-',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            return {
+                source: 'cli',
+                value: true,
+            };
+        }
+        if (enforceAudioTrackState !== DEFAULT_ENFORCE_AUDIO_TRACK) {
+            return {
+                source: 'config',
+                value: enforceAudioTrackState,
+            };
+        }
+        return {
+            source: 'default',
+            value: DEFAULT_ENFORCE_AUDIO_TRACK,
+        };
+    },
+    setConfig: (value) => {
+        enforceAudioTrackState = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/experimental-client-side-rendering.d.ts

@@ -0,0 +1,15 @@
+export declare const experimentalClientSideRenderingOption: {
+    name: string;
+    cliFlag: "enable-experimental-client-side-rendering";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/experimental-client-side-rendering.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.experimentalClientSideRenderingOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let experimentalClientSideRenderingEnabled = false;
+const cliFlag = 'enable-experimental-client-side-rendering';
+exports.experimentalClientSideRenderingOption = {
+    name: 'Enable Experimental Client-Side Rendering',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Enable WIP client-side rendering in the Remotion Studio. See https://www.remotion.dev/docs/client-side-rendering/ for notes." })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/client-side-rendering',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            experimentalClientSideRenderingEnabled = true;
+            return {
+                value: experimentalClientSideRenderingEnabled,
+                source: 'cli',
+            };
+        }
+        return {
+            value: experimentalClientSideRenderingEnabled,
+            source: 'config',
+        };
+    },
+    setConfig(value) {
+        experimentalClientSideRenderingEnabled = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/folder-expiry.d.ts

@@ -0,0 +1,15 @@
+export declare const folderExpiryOption: {
+    name: string;
+    cliFlag: "enable-folder-expiry";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "enableFolderExpiry";
+    docLink: string;
+    type: boolean | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: boolean | null;
+    };
+    setConfig: (value: boolean | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/folder-expiry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.folderExpiryOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let enableFolderExpiry = null;
+const cliFlag = 'enable-folder-expiry';
+exports.folderExpiryOption = {
+    name: 'Lambda render expiration',
+    cliFlag,
+    description: () => {
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["When deploying sites, enable or disable S3 Lifecycle policies which allow for renders to auto-delete after a certain time. Default is", ' ', jsx_runtime_1.jsx("code", { children: "null" }),
+                ", which does not change any lifecycle policies of the S3 bucket. See: ",
+                jsx_runtime_1.jsx("a", { href: "/docs/lambda/autodelete", children: "Lambda autodelete" }),
+                "."] }));
+    },
+    ssrName: 'enableFolderExpiry',
+    docLink: 'https://www.remotion.dev/docs/lambda/autodelete',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (enableFolderExpiry !== null) {
+            return {
+                source: 'config',
+                value: enableFolderExpiry,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        enableFolderExpiry = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/for-seamless-aac-concatenation.d.ts

@@ -0,0 +1,19 @@
+export declare const getForSeamlessAacConcatenation: () => boolean;
+export declare const forSeamlessAacConcatenationOption: {
+    name: string;
+    cliFlag: "for-seamless-aac-concatenation";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: true;
+    } | {
+        source: string;
+        value: false;
+    };
+    setConfig: (value: boolean) => void;
+    ssrName: string;
+    type: boolean;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/for-seamless-aac-concatenation.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forSeamlessAacConcatenationOption = exports.getForSeamlessAacConcatenation = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const DEFAULT = false;
+let forSeamlessAacConcatenation = DEFAULT;
+const getForSeamlessAacConcatenation = () => {
+    return forSeamlessAacConcatenation;
+};
+exports.getForSeamlessAacConcatenation = getForSeamlessAacConcatenation;
+const cliFlag = 'for-seamless-aac-concatenation';
+exports.forSeamlessAacConcatenationOption = {
+    name: 'For seamless AAC concatenation',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["If enabled, the audio is trimmed to the nearest AAC frame, which is required for seamless concatenation of AAC files. This is a requirement if you later want to combine multiple video snippets seamlessly.",
+            jsx_runtime_1.jsx("br", {}), jsx_runtime_1.jsx("br", {}),
+            " This option is used internally. There is currently no documentation yet for to concatenate the audio chunks."] })),
+    docLink: 'https://remotion.dev/docs/renderer',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            return {
+                source: 'cli',
+                value: true,
+            };
+        }
+        if (forSeamlessAacConcatenation !== DEFAULT) {
+            return {
+                source: 'config',
+                value: forSeamlessAacConcatenation,
+            };
+        }
+        return {
+            source: 'default',
+            value: DEFAULT,
+        };
+    },
+    setConfig: (value) => {
+        forSeamlessAacConcatenation = value;
+    },
+    ssrName: 'forSeamlessAacConcatenation',
+    type: false,
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/force-new-studio.d.ts

@@ -0,0 +1,15 @@
+export declare const forceNewStudioOption: {
+    name: string;
+    cliFlag: "force-new";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/force-new-studio.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forceNewStudioOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let forceNewEnabled = false;
+const cliFlag = 'force-new';
+exports.forceNewStudioOption = {
+    name: 'Force New Studio',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Forces starting a new Studio instance even if one is already running on the same port for the same project." })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/config#setforcenewstudioenabled',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        return {
+            value: forceNewEnabled,
+            source: 'config',
+        };
+    },
+    setConfig(value) {
+        forceNewEnabled = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/gl.d.ts

@@ -0,0 +1,24 @@
+export declare const validOpenGlRenderers: readonly ["swangle", "angle", "egl", "swiftshader", "vulkan", "angle-egl"];
+export type OpenGlRenderer = (typeof validOpenGlRenderers)[number];
+export declare const DEFAULT_OPENGL_RENDERER: OpenGlRenderer | null;
+export declare const getChromiumOpenGlRenderer: () => "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan" | null;
+export declare const setChromiumOpenGlRenderer: (renderer: "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan") => void;
+export declare const glOption: {
+    cliFlag: "gl";
+    docLink: string;
+    name: string;
+    type: "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan" | null;
+    ssrName: string;
+    description: () => import("react/jsx-runtime").JSX.Element;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan";
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (value: "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan" | null) => void;
+};
+export declare const validateOpenGlRenderer: (option: unknown) => "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan" | null;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/gl.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOpenGlRenderer = exports.glOption = exports.setChromiumOpenGlRenderer = exports.getChromiumOpenGlRenderer = exports.DEFAULT_OPENGL_RENDERER = exports.validOpenGlRenderers = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+exports.validOpenGlRenderers = [
+    'swangle',
+    'angle',
+    'egl',
+    'swiftshader',
+    'vulkan',
+    'angle-egl',
+];
+exports.DEFAULT_OPENGL_RENDERER = null;
+let openGlRenderer = exports.DEFAULT_OPENGL_RENDERER;
+const getChromiumOpenGlRenderer = () => openGlRenderer;
+exports.getChromiumOpenGlRenderer = getChromiumOpenGlRenderer;
+const setChromiumOpenGlRenderer = (renderer) => {
+    (0, exports.validateOpenGlRenderer)(renderer);
+    openGlRenderer = renderer;
+};
+exports.setChromiumOpenGlRenderer = setChromiumOpenGlRenderer;
+const AngleChangelog = () => {
+    return (jsx_runtime_1.jsxs("details", { style: { fontSize: '0.9em', marginBottom: '1em' }, children: [
+            jsx_runtime_1.jsx("summary", { children: "Changelog" }), jsx_runtime_1.jsxs("ul", { children: [
+                    jsx_runtime_1.jsxs("li", { children: ["From Remotion v2.6.7 until v3.0.7, the default for Remotion Lambda was", ' ', jsx_runtime_1.jsx("code", { children: "swiftshader" }),
+                            ", but from v3.0.8 the default is", ' ', jsx_runtime_1.jsx("code", { children: "swangle" }),
+                            " (Swiftshader on Angle) since Chrome 101 added support for it."] }), jsx_runtime_1.jsxs("li", { children: ["From Remotion v2.4.3 until v2.6.6, the default was ",
+                            jsx_runtime_1.jsx("code", { children: "angle" }),
+                            ", however it turns out to have a small memory leak that could crash long Remotion renders."] })
+                ] })
+        ] }));
+};
+const cliFlag = 'gl';
+exports.glOption = {
+    cliFlag,
+    docLink: 'https://www.remotion.dev/docs/chromium-flags#--gl',
+    name: 'OpenGL renderer',
+    type: 'angle',
+    ssrName: 'gl',
+    description: () => {
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: [
+                jsx_runtime_1.jsx(AngleChangelog, {}), jsx_runtime_1.jsxs("p", { children: ["Select the OpenGL renderer backend for Chromium. ",
+                        jsx_runtime_1.jsx("br", {}),
+                        "Accepted values:"] }), jsx_runtime_1.jsxs("ul", { children: [
+                        jsx_runtime_1.jsx("li", { children: jsx_runtime_1.jsx("code", { children: '"angle"' }) }), jsx_runtime_1.jsx("li", { children: jsx_runtime_1.jsx("code", { children: '"egl"' }) }), jsx_runtime_1.jsx("li", { children: jsx_runtime_1.jsx("code", { children: '"swiftshader"' }) }), jsx_runtime_1.jsx("li", { children: jsx_runtime_1.jsx("code", { children: '"swangle"' }) }), jsx_runtime_1.jsxs("li", { children: [
+                                jsx_runtime_1.jsx("code", { children: '"vulkan"' }),
+                                " (",
+                                jsx_runtime_1.jsx("em", { children: "from Remotion v4.0.41" }),
+                                ")"] }), jsx_runtime_1.jsxs("li", { children: [
+                                jsx_runtime_1.jsx("code", { children: '"angle-egl"' }),
+                                " (",
+                                jsx_runtime_1.jsx("em", { children: "from Remotion v4.0.51" }),
+                                ")"] })
+                    ] }), jsx_runtime_1.jsxs("p", { children: ["The default is ",
+                        jsx_runtime_1.jsx("code", { children: "null" }),
+                        ", letting Chrome decide, except on Lambda where the default is ",
+                        jsx_runtime_1.jsx("code", { children: '"swangle"' })
+                    ] })
+            ] }));
+    },
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            (0, exports.validateOpenGlRenderer)(commandLine[cliFlag]);
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (openGlRenderer !== exports.DEFAULT_OPENGL_RENDERER) {
+            return {
+                value: openGlRenderer,
+                source: 'config',
+            };
+        }
+        return {
+            value: exports.DEFAULT_OPENGL_RENDERER,
+            source: 'default',
+        };
+    },
+    setConfig: (value) => {
+        (0, exports.validateOpenGlRenderer)(value);
+        openGlRenderer = value;
+    },
+};
+const validateOpenGlRenderer = (option) => {
+    if (option === null) {
+        return null;
+    }
+    if (!exports.validOpenGlRenderers.includes(option)) {
+        throw new TypeError(`${option} is not a valid GL backend. Accepted values: ${exports.validOpenGlRenderers.join(', ')}`);
+    }
+    return option;
+};
+exports.validateOpenGlRenderer = validateOpenGlRenderer;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/hardware-acceleration.d.ts

@@ -0,0 +1,18 @@
+export declare const hardwareAccelerationOptions: readonly ["disable", "if-possible", "required"];
+export type HardwareAccelerationOption = (typeof hardwareAccelerationOptions)[number];
+export declare const getHardwareAcceleration: () => "disable" | "if-possible" | "required" | null;
+export declare const hardwareAccelerationOption: {
+    name: string;
+    cliFlag: "hardware-acceleration";
+    description: () => string;
+    ssrName: string;
+    docLink: string;
+    type: "disable" | "if-possible" | "required";
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: "disable" | "if-possible" | "required";
+    };
+    setConfig: (value: "disable" | "if-possible" | "required") => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/hardware-acceleration.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hardwareAccelerationOption = exports.getHardwareAcceleration = exports.hardwareAccelerationOptions = void 0;
+exports.hardwareAccelerationOptions = [
+    'disable',
+    'if-possible',
+    'required',
+];
+const cliFlag = 'hardware-acceleration';
+let currentValue = null;
+const getHardwareAcceleration = () => {
+    return currentValue;
+};
+exports.getHardwareAcceleration = getHardwareAcceleration;
+exports.hardwareAccelerationOption = {
+    name: 'Hardware Acceleration',
+    cliFlag,
+    description: () => `
+			One of
+			${new Intl.ListFormat('en', { type: 'disjunction' }).format(exports.hardwareAccelerationOptions.map((a) => JSON.stringify(a)))}
+			. Default "disable". Encode using a hardware-accelerated encoder if
+			available. If set to "required" and no hardware-accelerated encoder is
+			available, then the render will fail.
+		`,
+    ssrName: 'hardwareAcceleration',
+    docLink: 'https://www.remotion.dev/docs/encoding',
+    type: 'disable',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            const value = commandLine[cliFlag];
+            if (!exports.hardwareAccelerationOptions.includes(value)) {
+                throw new Error(`Invalid value for --${cliFlag}: ${value}`);
+            }
+            return {
+                source: 'cli',
+                value,
+            };
+        }
+        if (currentValue !== null) {
+            return {
+                source: 'config',
+                value: currentValue,
+            };
+        }
+        return {
+            source: 'default',
+            value: 'disable',
+        };
+    },
+    setConfig: (value) => {
+        if (!exports.hardwareAccelerationOptions.includes(value)) {
+            throw new Error(`Invalid value for --${cliFlag}: ${value}`);
+        }
+        currentValue = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/headless.d.ts

@@ -0,0 +1,15 @@
+export declare const headlessOption: {
+    name: string;
+    cliFlag: "disable-headless";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: boolean;
+    };
+    setConfig: (value: boolean) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/headless.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.headlessOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const DEFAULT = true;
+let headlessMode = DEFAULT;
+const cliFlag = 'disable-headless';
+exports.headlessOption = {
+    name: 'Disable Headless Mode',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Deprecated - will be removed in 5.0.0. With the migration to", ' ', jsx_runtime_1.jsx("a", { href: "/docs/miscellaneous/chrome-headless-shell", children: "Chrome Headless Shell" }),
+            ", this option is not functional anymore.",
+            jsx_runtime_1.jsx("br", {}), jsx_runtime_1.jsx("br", {}),
+            " If disabled, the render will open an actual Chrome window where you can see the render happen. The default is headless mode."] })),
+    ssrName: 'headless',
+    docLink: 'https://www.remotion.dev/docs/chromium-flags#--disable-headless',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: !commandLine[cliFlag],
+            };
+        }
+        if (headlessMode !== DEFAULT) {
+            return {
+                source: 'config',
+                value: headlessMode,
+            };
+        }
+        return {
+            source: 'default',
+            value: headlessMode,
+        };
+    },
+    setConfig: (value) => {
+        headlessMode = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/image-sequence-pattern.d.ts

@@ -0,0 +1,15 @@
+export declare const imageSequencePatternOption: {
+    name: string;
+    cliFlag: "image-sequence-pattern";
+    ssrName: string;
+    description: () => import("react/jsx-runtime").JSX.Element;
+    docLink: null;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: string;
+        source: string;
+    };
+    setConfig: (pattern: string | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/image-sequence-pattern.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.imageSequencePatternOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'image-sequence-pattern';
+let currentImageSequencePattern = null;
+// Option for --image-sequence-pattern
+exports.imageSequencePatternOption = {
+    name: 'Image Sequence Pattern',
+    cliFlag,
+    ssrName: 'imageSequencePattern',
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Pattern for naming image sequence files. Supports ",
+            jsx_runtime_1.jsx("code", { children: "[frame]" }),
+            " for the zero-padded frame number and ",
+            jsx_runtime_1.jsx("code", { children: "[ext]" }),
+            " for the file extension."] })),
+    docLink: null,
+    type: 'string',
+    getValue: ({ commandLine }) => {
+        if (currentImageSequencePattern !== null) {
+            return {
+                value: currentImageSequencePattern,
+                source: 'config',
+            };
+        }
+        return {
+            value: commandLine[cliFlag],
+            source: 'cli',
+        };
+    },
+    setConfig: (pattern) => {
+        currentImageSequencePattern = pattern;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/index.d.ts

@@ -0,0 +1,897 @@
+import type { AnyRemotionOption } from './option';
+export declare const allOptions: {
+    audioCodecOption: {
+        cliFlag: "audio-codec";
+        setConfig: (audioCodec: "aac" | "mp3" | "opus" | "pcm-16" | null) => void;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: "aac" | "mp3" | "opus" | "pcm-16";
+        } | {
+            source: string;
+            value: null;
+        };
+        description: () => string;
+        docLink: string;
+        name: string;
+        ssrName: "audioCodec";
+        type: "aac" | "mp3" | "opus" | "pcm-16";
+    };
+    scaleOption: {
+        name: string;
+        cliFlag: "scale";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: number;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: number;
+        };
+        setConfig: (scale: number) => void;
+    };
+    crfOption: {
+        name: string;
+        cliFlag: "crf";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: number;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: import("..").Crf;
+        };
+        setConfig: (crf: import("..").Crf) => void;
+    };
+    jpegQualityOption: {
+        name: string;
+        cliFlag: "jpeg-quality";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: number;
+        setConfig: (q: number | undefined) => void;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: number;
+        };
+    };
+    videoBitrateOption: {
+        name: string;
+        cliFlag: "video-bitrate";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: string | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string | null;
+        };
+        setConfig: (bitrate: string | null) => void;
+    };
+    audioBitrateOption: {
+        name: string;
+        cliFlag: "audio-bitrate";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: string;
+            source: string;
+        } | {
+            value: null;
+            source: string;
+        };
+        setConfig: (value: string | null) => void;
+    };
+    enforceAudioOption: {
+        name: string;
+        cliFlag: "enforce-audio-track";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: true;
+        } | {
+            source: string;
+            value: false;
+        };
+        setConfig: (value: boolean) => void;
+    };
+    mutedOption: {
+        name: string;
+        cliFlag: "muted";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean;
+        };
+        setConfig: () => void;
+    };
+    videoCodecOption: {
+        name: string;
+        cliFlag: "codec";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }, { compositionCodec, configFile, downloadName, outName, uiCodec, }: {
+            outName: string | null;
+            downloadName: string | null;
+            configFile: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav" | null;
+            uiCodec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav" | null;
+            compositionCodec: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav" | null;
+        }) => {
+            value: "aac" | "gif" | "h264" | "h264-mkv" | "h264-ts" | "h265" | "mp3" | "prores" | "vp8" | "vp9" | "wav";
+            source: string;
+        };
+        setConfig: (newCodec: import("..").CodecOrUndefined) => void;
+    };
+    offthreadVideoCacheSizeInBytesOption: {
+        name: string;
+        cliFlag: "offthreadvideo-cache-size-in-bytes";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "offthreadVideoCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: number;
+        } | {
+            source: string;
+            value: null;
+        };
+        setConfig: (size: number | null) => void;
+    };
+    offthreadVideoThreadsOption: {
+        name: string;
+        cliFlag: "offthreadvideo-video-threads";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "offthreadVideoThreads";
+        docLink: string;
+        type: number | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: number;
+        } | {
+            source: string;
+            value: null;
+        };
+        setConfig: (size: number | null) => void;
+    };
+    webhookCustomDataOption: {
+        name: string;
+        cliFlag: "webhook-custom-data";
+        description: (type: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
+        ssrName: "customData";
+        docLink: string;
+        type: Record<string, unknown> | null;
+        getValue: () => never;
+        setConfig: () => never;
+    };
+    colorSpaceOption: {
+        name: string;
+        cliFlag: "color-space";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        ssrName: string;
+        type: "bt2020-ncl" | "bt709" | "default" | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: "bt2020-ncl" | "bt709" | "default";
+        };
+        setConfig: (value: "bt2020-ncl" | "bt709" | "default" | null) => void;
+    };
+    deleteAfterOption: {
+        name: string;
+        cliFlag: "delete-after";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "deleteAfter";
+        docLink: string;
+        type: import("./delete-after").DeleteAfter | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: import("./delete-after").DeleteAfter;
+        } | {
+            source: string;
+            value: null;
+        };
+        setConfig: (value: import("./delete-after").DeleteAfter | null) => void;
+    };
+    disallowParallelEncodingOption: {
+        name: string;
+        cliFlag: "disallow-parallel-encoding";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+    folderExpiryOption: {
+        name: string;
+        cliFlag: "enable-folder-expiry";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "enableFolderExpiry";
+        docLink: string;
+        type: boolean | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean | null;
+        };
+        setConfig: (value: boolean | null) => void;
+    };
+    enableMultiprocessOnLinuxOption: {
+        name: string;
+        cliFlag: "enable-multiprocess-on-linux";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean;
+        };
+        setConfig: (value: boolean) => void;
+    };
+    glOption: {
+        cliFlag: "gl";
+        docLink: string;
+        name: string;
+        type: "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan" | null;
+        ssrName: string;
+        description: () => import("react/jsx-runtime").JSX.Element;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan";
+            source: string;
+        } | {
+            value: null;
+            source: string;
+        };
+        setConfig: (value: "angle" | "angle-egl" | "egl" | "swangle" | "swiftshader" | "vulkan" | null) => void;
+    };
+    enableLambdaInsights: {
+        name: string;
+        cliFlag: "enable-lambda-insights";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        setConfig: (value: boolean) => void;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+    };
+    encodingMaxRateOption: {
+        name: string;
+        cliFlag: "max-rate";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "encodingMaxRate";
+        docLink: string;
+        type: string | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: string;
+            source: string;
+        } | {
+            value: null;
+            source: string;
+        };
+        setConfig: (newMaxRate: string | null) => void;
+    };
+    encodingBufferSizeOption: {
+        name: string;
+        cliFlag: "buffer-size";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "encodingBufferSize";
+        docLink: string;
+        type: string | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: string;
+            source: string;
+        } | {
+            value: null;
+            source: string;
+        };
+        setConfig: (bitrate: string | null) => void;
+    };
+    beepOnFinishOption: {
+        name: string;
+        cliFlag: "beep-on-finish";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+    numberOfGifLoopsOption: {
+        name: string;
+        cliFlag: "number-of-gif-loops";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "numberOfGifLoops";
+        docLink: string;
+        type: number | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: number;
+            source: string;
+        } | {
+            value: null;
+            source: string;
+        };
+        setConfig: (newLoop: import("./number-of-gif-loops").NumberOfGifLoops) => void;
+    };
+    reproOption: {
+        name: string;
+        cliFlag: "repro";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig: (should: boolean) => void;
+    };
+    preferLosslessOption: {
+        name: string;
+        cliFlag: "prefer-lossless";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        type: boolean;
+        ssrName: "preferLossless";
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: true;
+            source: string;
+        } | {
+            value: false;
+            source: string;
+        };
+        setConfig: (val: boolean) => void;
+    };
+    x264Option: {
+        name: string;
+        cliFlag: "x264-preset";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "x264Preset";
+        docLink: string;
+        type: "fast" | "faster" | "medium" | "placebo" | "slow" | "slower" | "superfast" | "ultrafast" | "veryfast" | "veryslow" | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: "fast" | "faster" | "medium" | "placebo" | "slow" | "slower" | "superfast" | "ultrafast" | "veryfast" | "veryslow";
+            source: string;
+        } | {
+            value: null;
+            source: string;
+        };
+        setConfig: (profile: "fast" | "faster" | "medium" | "placebo" | "slow" | "slower" | "superfast" | "ultrafast" | "veryfast" | "veryslow" | null) => void;
+    };
+    logLevelOption: {
+        cliFlag: "log";
+        name: string;
+        ssrName: string;
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: "error" | "info" | "trace" | "verbose" | "warn";
+            source: string;
+        };
+        setConfig: (newLogLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
+        type: "error" | "info" | "trace" | "verbose" | "warn";
+    };
+    delayRenderTimeoutInMillisecondsOption: {
+        name: string;
+        cliFlag: "timeout";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "timeoutInMilliseconds";
+        docLink: string;
+        type: number;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: number;
+        };
+        setConfig: (value: number) => void;
+    };
+    headlessOption: {
+        name: string;
+        cliFlag: "disable-headless";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean;
+        };
+        setConfig: (value: boolean) => void;
+    };
+    overwriteOption: {
+        name: string;
+        cliFlag: "overwrite";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }, defaultValue: boolean) => {
+            source: string;
+            value: boolean;
+        };
+        setConfig: (value: boolean) => void;
+    };
+    binariesDirectoryOption: {
+        name: string;
+        cliFlag: "binaries-directory";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "binariesDirectory";
+        docLink: string;
+        type: string | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string | null;
+        };
+        setConfig: (value: string | null) => void;
+    };
+    forSeamlessAacConcatenationOption: {
+        name: string;
+        cliFlag: "for-seamless-aac-concatenation";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: true;
+        } | {
+            source: string;
+            value: false;
+        };
+        setConfig: (value: boolean) => void;
+        ssrName: string;
+        type: boolean;
+    };
+    separateAudioOption: {
+        cliFlag: string;
+        description: () => string;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string;
+        } | {
+            source: string;
+            value: null;
+        };
+        name: string;
+        setConfig: () => never;
+        ssrName: string;
+        type: string | null;
+    };
+    publicPathOption: {
+        name: string;
+        cliFlag: "public-path";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "publicPath";
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string;
+        } | {
+            source: string;
+            value: null;
+        };
+        setConfig: (value: string | null) => void;
+        type: string | null;
+    };
+    publicDirOption: {
+        name: string;
+        cliFlag: "public-dir";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "publicDir";
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string;
+        } | {
+            source: string;
+            value: null;
+        };
+        setConfig: (value: string | null) => void;
+        type: string | null;
+    };
+    onBrowserDownloadOption: {
+        name: string;
+        cliFlag: "on-browser-download";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "onBrowserDownload";
+        docLink: string;
+        type: import("./on-browser-download").OnBrowserDownload;
+        getValue: () => never;
+        setConfig: () => never;
+    };
+    throwIfSiteExistsOption: {
+        cliFlag: string;
+        description: () => string;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean;
+        };
+        name: string;
+        setConfig: () => never;
+        ssrName: string;
+        type: boolean;
+    };
+    disableGitSourceOption: {
+        cliFlag: string;
+        description: () => string;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean;
+        };
+        name: string;
+        setConfig: () => never;
+        ssrName: string;
+        type: boolean;
+    };
+    metadataOption: {
+        name: string;
+        cliFlag: "metadata";
+        description: (mode: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        type: import("./metadata").Metadata;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: {
+                [k: string]: string;
+            };
+        };
+        setConfig: (newMetadata: import("./metadata").Metadata) => void;
+        ssrName: string;
+    };
+    hardwareAccelerationOption: {
+        name: string;
+        cliFlag: "hardware-acceleration";
+        description: () => string;
+        ssrName: string;
+        docLink: string;
+        type: "disable" | "if-possible" | "required";
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: "disable" | "if-possible" | "required";
+        };
+        setConfig: (value: "disable" | "if-possible" | "required") => void;
+    };
+    chromeModeOption: {
+        cliFlag: "chrome-mode";
+        name: string;
+        ssrName: string;
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: "chrome-for-testing" | "headless-shell";
+            source: string;
+        };
+        setConfig: (newChromeMode: "chrome-for-testing" | "headless-shell") => void;
+        type: "chrome-for-testing" | "headless-shell";
+    };
+    apiKeyOption: {
+        name: string;
+        cliFlag: "api-key";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "apiKey";
+        docLink: string;
+        type: string | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string | null;
+        };
+        setConfig: (value: string | null) => void;
+    };
+    licenseKeyOption: {
+        name: string;
+        cliFlag: "license-key";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "licenseKey";
+        docLink: string;
+        type: string | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string | null;
+        };
+        setConfig: (value: string | null) => void;
+    };
+    audioLatencyHintOption: {
+        name: string;
+        cliFlag: "audio-latency-hint";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "audioLatencyHint";
+        docLink: string;
+        type: AudioContextLatencyCategory;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: AudioContextLatencyCategory;
+            source: string;
+        } | {
+            value: null;
+            source: string;
+        };
+        setConfig: (profile: AudioContextLatencyCategory | null) => void;
+    };
+    enableCrossSiteIsolationOption: {
+        name: string;
+        cliFlag: "cross-site-isolation";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+    imageSequencePatternOption: {
+        name: string;
+        cliFlag: "image-sequence-pattern";
+        ssrName: string;
+        description: () => import("react/jsx-runtime").JSX.Element;
+        docLink: null;
+        type: string | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: string;
+            source: string;
+        };
+        setConfig: (pattern: string | null) => void;
+    };
+    mediaCacheSizeInBytesOption: {
+        name: string;
+        cliFlag: "media-cache-size-in-bytes";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "mediaCacheSizeInBytes";
+        docLink: string;
+        type: number | null;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: number;
+        } | {
+            source: string;
+            value: null;
+        };
+        setConfig: (size: number | null) => void;
+    };
+    darkModeOption: {
+        name: string;
+        cliFlag: "dark-mode";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: string;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean;
+        };
+        setConfig: (value: boolean) => void;
+    };
+    publicLicenseKeyOption: {
+        name: string;
+        cliFlag: "public-license-key";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "publicLicenseKey";
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: string | null;
+        };
+        setConfig: (value: string | null) => void;
+        type: string | null;
+    };
+    isProductionOption: {
+        name: string;
+        cliFlag: "is-production";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: "isProduction";
+        docLink: string;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            source: string;
+            value: boolean | null;
+        };
+        setConfig: (value: boolean | null) => void;
+        type: boolean | null;
+    };
+    askAIOption: {
+        name: string;
+        cliFlag: "disable-ask-ai";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+    experimentalClientSideRenderingOption: {
+        name: string;
+        cliFlag: "enable-experimental-client-side-rendering";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+    keyboardShortcutsOption: {
+        name: string;
+        cliFlag: "disable-keyboard-shortcuts";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+    forceNewStudioOption: {
+        name: string;
+        cliFlag: "force-new";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+    numberOfSharedAudioTagsOption: {
+        name: string;
+        cliFlag: "number-of-shared-audio-tags";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: number;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: number;
+            source: string;
+        };
+        setConfig(value: number): void;
+    };
+    ipv4Option: {
+        name: string;
+        cliFlag: "ipv4";
+        description: () => import("react/jsx-runtime").JSX.Element;
+        ssrName: null;
+        docLink: string;
+        type: boolean;
+        getValue: ({ commandLine }: {
+            commandLine: Record<string, unknown>;
+        }) => {
+            value: boolean;
+            source: string;
+        };
+        setConfig(value: boolean): void;
+    };
+};
+export type AvailableOptions = keyof typeof allOptions;
+export type TypeOfOption<Type> = Type extends AnyRemotionOption<infer X> ? X : never;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/index.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allOptions = void 0;
+const api_key_1 = require("./api-key");
+const ask_ai_1 = require("./ask-ai");
+const audio_bitrate_1 = require("./audio-bitrate");
+const audio_codec_1 = require("./audio-codec");
+const beep_on_finish_1 = require("./beep-on-finish");
+const binaries_directory_1 = require("./binaries-directory");
+const chrome_mode_1 = require("./chrome-mode");
+const color_space_1 = require("./color-space");
+const crf_1 = require("./crf");
+const cross_site_isolation_1 = require("./cross-site-isolation");
+const dark_mode_1 = require("./dark-mode");
+const delete_after_1 = require("./delete-after");
+const disable_git_source_1 = require("./disable-git-source");
+const disallow_parallel_encoding_1 = require("./disallow-parallel-encoding");
+const enable_lambda_insights_1 = require("./enable-lambda-insights");
+const enable_multiprocess_on_linux_1 = require("./enable-multiprocess-on-linux");
+const encoding_buffer_size_1 = require("./encoding-buffer-size");
+const encoding_max_rate_1 = require("./encoding-max-rate");
+const enforce_audio_1 = require("./enforce-audio");
+const experimental_client_side_rendering_1 = require("./experimental-client-side-rendering");
+const folder_expiry_1 = require("./folder-expiry");
+const for_seamless_aac_concatenation_1 = require("./for-seamless-aac-concatenation");
+const force_new_studio_1 = require("./force-new-studio");
+const gl_1 = require("./gl");
+const hardware_acceleration_1 = require("./hardware-acceleration");
+const headless_1 = require("./headless");
+const image_sequence_pattern_1 = require("./image-sequence-pattern");
+const ipv4_1 = require("./ipv4");
+const is_production_1 = require("./is-production");
+const jpeg_quality_1 = require("./jpeg-quality");
+const keyboard_shortcuts_1 = require("./keyboard-shortcuts");
+const latency_hint_1 = require("./latency-hint");
+const license_key_1 = require("./license-key");
+const log_level_1 = require("./log-level");
+const metadata_1 = require("./metadata");
+const mute_1 = require("./mute");
+const number_of_gif_loops_1 = require("./number-of-gif-loops");
+const number_of_shared_audio_tags_1 = require("./number-of-shared-audio-tags");
+const offthreadvideo_cache_size_1 = require("./offthreadvideo-cache-size");
+const offthreadvideo_threads_1 = require("./offthreadvideo-threads");
+const on_browser_download_1 = require("./on-browser-download");
+const overwrite_1 = require("./overwrite");
+const prefer_lossless_1 = require("./prefer-lossless");
+const public_dir_1 = require("./public-dir");
+const public_license_key_1 = require("./public-license-key");
+const public_path_1 = require("./public-path");
+const repro_1 = require("./repro");
+const scale_1 = require("./scale");
+const separate_audio_1 = require("./separate-audio");
+const throw_if_site_exists_1 = require("./throw-if-site-exists");
+const timeout_1 = require("./timeout");
+const video_bitrate_1 = require("./video-bitrate");
+const video_cache_size_1 = require("./video-cache-size");
+const video_codec_1 = require("./video-codec");
+const webhook_custom_data_1 = require("./webhook-custom-data");
+const x264_preset_1 = require("./x264-preset");
+exports.allOptions = {
+    audioCodecOption: audio_codec_1.audioCodecOption,
+    scaleOption: scale_1.scaleOption,
+    crfOption: crf_1.crfOption,
+    jpegQualityOption: jpeg_quality_1.jpegQualityOption,
+    videoBitrateOption: video_bitrate_1.videoBitrateOption,
+    audioBitrateOption: audio_bitrate_1.audioBitrateOption,
+    enforceAudioOption: enforce_audio_1.enforceAudioOption,
+    mutedOption: mute_1.mutedOption,
+    videoCodecOption: video_codec_1.videoCodecOption,
+    offthreadVideoCacheSizeInBytesOption: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+    offthreadVideoThreadsOption: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+    webhookCustomDataOption: webhook_custom_data_1.webhookCustomDataOption,
+    colorSpaceOption: color_space_1.colorSpaceOption,
+    deleteAfterOption: delete_after_1.deleteAfterOption,
+    disallowParallelEncodingOption: disallow_parallel_encoding_1.disallowParallelEncodingOption,
+    folderExpiryOption: folder_expiry_1.folderExpiryOption,
+    enableMultiprocessOnLinuxOption: enable_multiprocess_on_linux_1.enableMultiprocessOnLinuxOption,
+    glOption: gl_1.glOption,
+    enableLambdaInsights: enable_lambda_insights_1.enableLambdaInsights,
+    encodingMaxRateOption: encoding_max_rate_1.encodingMaxRateOption,
+    encodingBufferSizeOption: encoding_buffer_size_1.encodingBufferSizeOption,
+    beepOnFinishOption: beep_on_finish_1.beepOnFinishOption,
+    numberOfGifLoopsOption: number_of_gif_loops_1.numberOfGifLoopsOption,
+    reproOption: repro_1.reproOption,
+    preferLosslessOption: prefer_lossless_1.preferLosslessAudioOption,
+    x264Option: x264_preset_1.x264Option,
+    logLevelOption: log_level_1.logLevelOption,
+    delayRenderTimeoutInMillisecondsOption: timeout_1.delayRenderTimeoutInMillisecondsOption,
+    headlessOption: headless_1.headlessOption,
+    overwriteOption: overwrite_1.overwriteOption,
+    binariesDirectoryOption: binaries_directory_1.binariesDirectoryOption,
+    forSeamlessAacConcatenationOption: for_seamless_aac_concatenation_1.forSeamlessAacConcatenationOption,
+    separateAudioOption: separate_audio_1.separateAudioOption,
+    publicPathOption: public_path_1.publicPathOption,
+    publicDirOption: public_dir_1.publicDirOption,
+    onBrowserDownloadOption: on_browser_download_1.onBrowserDownloadOption,
+    throwIfSiteExistsOption: throw_if_site_exists_1.throwIfSiteExistsOption,
+    disableGitSourceOption: disable_git_source_1.disableGitSourceOption,
+    metadataOption: metadata_1.metadataOption,
+    hardwareAccelerationOption: hardware_acceleration_1.hardwareAccelerationOption,
+    chromeModeOption: chrome_mode_1.chromeModeOption,
+    apiKeyOption: api_key_1.apiKeyOption,
+    licenseKeyOption: license_key_1.licenseKeyOption,
+    audioLatencyHintOption: latency_hint_1.audioLatencyHintOption,
+    enableCrossSiteIsolationOption: cross_site_isolation_1.enableCrossSiteIsolationOption,
+    imageSequencePatternOption: image_sequence_pattern_1.imageSequencePatternOption,
+    mediaCacheSizeInBytesOption: video_cache_size_1.mediaCacheSizeInBytesOption,
+    darkModeOption: dark_mode_1.darkModeOption,
+    publicLicenseKeyOption: public_license_key_1.publicLicenseKeyOption,
+    isProductionOption: is_production_1.isProductionOption,
+    askAIOption: ask_ai_1.askAIOption,
+    experimentalClientSideRenderingOption: experimental_client_side_rendering_1.experimentalClientSideRenderingOption,
+    keyboardShortcutsOption: keyboard_shortcuts_1.keyboardShortcutsOption,
+    forceNewStudioOption: force_new_studio_1.forceNewStudioOption,
+    numberOfSharedAudioTagsOption: number_of_shared_audio_tags_1.numberOfSharedAudioTagsOption,
+    ipv4Option: ipv4_1.ipv4Option,
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/ipv4.d.ts

@@ -0,0 +1,15 @@
+export declare const ipv4Option: {
+    name: string;
+    cliFlag: "ipv4";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/ipv4.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipv4Option = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let forceIPv4 = false;
+const cliFlag = 'ipv4';
+exports.ipv4Option = {
+    name: 'IPv4',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Forces Remotion to bind to an IPv4 interface for the Studio server." })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/cli/studio',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        return {
+            value: forceIPv4,
+            source: 'config',
+        };
+    },
+    setConfig(value) {
+        forceIPv4 = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/is-production.d.ts

@@ -0,0 +1,15 @@
+export declare const isProductionOption: {
+    name: string;
+    cliFlag: "is-production";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "isProduction";
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: boolean | null;
+    };
+    setConfig: (value: boolean | null) => void;
+    type: boolean | null;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/is-production.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProductionOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'is-production';
+let currentIsProductionKey = null;
+exports.isProductionOption = {
+    name: 'Is Production',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Pass ",
+            jsx_runtime_1.jsx("code", { children: "false" }),
+            " if this a development render to not count it as a billable render on remotion.pro. Only can be used in conjuction with", ' ', jsx_runtime_1.jsx("code", { children: "licenseKey" }),
+            "."] })),
+    ssrName: 'isProduction',
+    docLink: 'https://www.remotion.dev/docs/licensing',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentIsProductionKey !== null) {
+            return {
+                source: 'config',
+                value: currentIsProductionKey,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        currentIsProductionKey = value;
+    },
+    type: false,
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/jpeg-quality.d.ts

@@ -0,0 +1,17 @@
+export declare const setJpegQuality: (q: number | undefined) => void;
+export declare const getJpegQuality: () => number;
+export declare const jpegQualityOption: {
+    name: string;
+    cliFlag: "jpeg-quality";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: number;
+    setConfig: (q: number | undefined) => void;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: number;
+    };
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/jpeg-quality.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jpegQualityOption = exports.getJpegQuality = exports.setJpegQuality = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const jpeg_quality_1 = require("../jpeg-quality");
+const defaultValue = jpeg_quality_1.DEFAULT_JPEG_QUALITY;
+let quality = defaultValue;
+const setJpegQuality = (q) => {
+    (0, jpeg_quality_1.validateJpegQuality)(q);
+    if (q === 0 || q === undefined) {
+        quality = defaultValue;
+        return;
+    }
+    quality = q;
+};
+exports.setJpegQuality = setJpegQuality;
+const getJpegQuality = () => quality;
+exports.getJpegQuality = getJpegQuality;
+const cliFlag = 'jpeg-quality';
+exports.jpegQualityOption = {
+    name: 'JPEG Quality',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Sets the quality of the generated JPEG images. Must be an integer between 0 and 100. Default: 80." })),
+    ssrName: 'jpegQuality',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media#jpeg-quality',
+    type: 0,
+    setConfig: exports.setJpegQuality,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            (0, jpeg_quality_1.validateJpegQuality)(commandLine[cliFlag]);
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (quality !== defaultValue) {
+            return {
+                source: 'config',
+                value: quality,
+            };
+        }
+        return {
+            source: 'default',
+            value: defaultValue,
+        };
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/keyboard-shortcuts.d.ts

@@ -0,0 +1,15 @@
+export declare const keyboardShortcutsOption: {
+    name: string;
+    cliFlag: "disable-keyboard-shortcuts";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: boolean;
+        source: string;
+    };
+    setConfig(value: boolean): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/keyboard-shortcuts.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyboardShortcutsOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let keyboardShortcutsEnabled = true;
+const cliFlag = 'disable-keyboard-shortcuts';
+exports.keyboardShortcutsOption = {
+    name: 'Disable or Enable keyboard shortcuts',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "Enable or disable keyboard shortcuts in the Remotion Studio." })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/config#setkeyboardshortcutsenabled',
+    type: false,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            keyboardShortcutsEnabled = commandLine[cliFlag] === false;
+            return {
+                value: keyboardShortcutsEnabled,
+                source: 'cli',
+            };
+        }
+        return {
+            value: keyboardShortcutsEnabled,
+            source: 'config',
+        };
+    },
+    setConfig(value) {
+        keyboardShortcutsEnabled = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/latency-hint.d.ts

@@ -0,0 +1,18 @@
+export declare const audioLatencyHintOption: {
+    name: string;
+    cliFlag: "audio-latency-hint";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "audioLatencyHint";
+    docLink: string;
+    type: AudioContextLatencyCategory;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: AudioContextLatencyCategory;
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (profile: AudioContextLatencyCategory | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/latency-hint.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.audioLatencyHintOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'audio-latency-hint';
+let value = null;
+exports.audioLatencyHintOption = {
+    name: 'Audio Latency Hint',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Sets the", ' ', jsx_runtime_1.jsx("a", { href: "https://developer.mozilla.org/en-US/docs/Web/API/AudioContext/AudioContext", children: "audio latency" }), ' ', "hint for the global ",
+            jsx_runtime_1.jsx("code", { children: "AudioContext" }),
+            " context that Remotion uses to play audio.",
+            jsx_runtime_1.jsx("br", {}),
+            "Possible values: ",
+            jsx_runtime_1.jsx("code", { children: "interactive" }),
+            ", ",
+            jsx_runtime_1.jsx("code", { children: "balanced" }),
+            ",", ' ', jsx_runtime_1.jsx("code", { children: "playback" })
+        ] })),
+    ssrName: 'audioLatencyHint',
+    docLink: 'https://www.remotion.dev/docs/renderer/render-media',
+    type: 'interactive',
+    getValue: ({ commandLine }) => {
+        const val = commandLine[cliFlag];
+        if (typeof val !== 'undefined') {
+            return { value: val, source: 'cli' };
+        }
+        if (value !== null) {
+            return { value, source: 'config' };
+        }
+        return { value: null, source: 'default' };
+    },
+    setConfig: (profile) => {
+        value = profile;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/license-key.d.ts

@@ -0,0 +1,15 @@
+export declare const licenseKeyOption: {
+    name: string;
+    cliFlag: "license-key";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "licenseKey";
+    docLink: string;
+    type: string | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (value: string | null) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/license-key.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.licenseKeyOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let currentLicenseKey = null;
+const cliFlag = 'license-key';
+exports.licenseKeyOption = {
+    name: 'License key',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["License key for sending a usage event using", ' ', jsx_runtime_1.jsx("code", { children: "@remotion/licensing" }),
+            "."] })),
+    ssrName: 'licenseKey',
+    docLink: 'https://www.remotion.dev/docs/licensing',
+    type: null,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        return {
+            source: 'default',
+            value: currentLicenseKey,
+        };
+    },
+    setConfig: (value) => {
+        currentLicenseKey = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/log-level.d.ts

@@ -0,0 +1,15 @@
+export declare const logLevelOption: {
+    cliFlag: "log";
+    name: string;
+    ssrName: string;
+    description: () => import("react/jsx-runtime").JSX.Element;
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: "error" | "info" | "trace" | "verbose" | "warn";
+        source: string;
+    };
+    setConfig: (newLogLevel: "error" | "info" | "trace" | "verbose" | "warn") => void;
+    type: "error" | "info" | "trace" | "verbose" | "warn";
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/log-level.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logLevelOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const log_level_1 = require("../log-level");
+let logLevel = 'info';
+const cliFlag = 'log';
+exports.logLevelOption = {
+    cliFlag,
+    name: 'Log Level',
+    ssrName: 'logLevel',
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["One of ",
+            jsx_runtime_1.jsx("code", { children: "trace" }),
+            ", ",
+            jsx_runtime_1.jsx("code", { children: "verbose" }),
+            ", ",
+            jsx_runtime_1.jsx("code", { children: "info" }),
+            ",", ' ', jsx_runtime_1.jsx("code", { children: "warn" }),
+            ", ",
+            jsx_runtime_1.jsx("code", { children: "error" }),
+            ".",
+            jsx_runtime_1.jsx("br", {}),
+            " Determines how much info is being logged to the console.",
+            jsx_runtime_1.jsx("br", {}), jsx_runtime_1.jsx("br", {}),
+            " Default ",
+            jsx_runtime_1.jsx("code", { children: "info" }),
+            "."] })),
+    docLink: 'https://www.remotion.dev/docs/troubleshooting/debug-failed-render',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            if (!(0, log_level_1.isValidLogLevel)(commandLine[cliFlag])) {
+                throw new Error(`Invalid \`--log\` value passed. Accepted values: ${log_level_1.logLevels
+                    .map((l) => `'${l}'`)
+                    .join(', ')}.`);
+            }
+            return { value: commandLine[cliFlag], source: 'cli' };
+        }
+        if (logLevel !== 'info') {
+            return { value: logLevel, source: 'config' };
+        }
+        return { value: 'info', source: 'default' };
+    },
+    setConfig: (newLogLevel) => {
+        logLevel = newLogLevel;
+    },
+    type: 'error',
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/metadata.d.ts

@@ -0,0 +1,18 @@
+export type Metadata = Record<string, string>;
+export declare const metadataOption: {
+    name: string;
+    cliFlag: "metadata";
+    description: (mode: "cli" | "ssr") => import("react/jsx-runtime").JSX.Element;
+    docLink: string;
+    type: Metadata;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: {
+            [k: string]: string;
+        };
+    };
+    setConfig: (newMetadata: Metadata) => void;
+    ssrName: string;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/metadata.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.metadataOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let metadata = {};
+const cliFlag = 'metadata';
+exports.metadataOption = {
+    name: 'Metadata',
+    cliFlag,
+    description: (mode) => {
+        if (mode === 'ssr') {
+            return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["An object containing metadata to be embedded in the video. See", ' ', jsx_runtime_1.jsx("a", { href: "/docs/metadata", children: "here" }),
+                    " for which metadata is accepted."] }));
+        }
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Metadata to be embedded in the video. See", ' ', jsx_runtime_1.jsx("a", { href: "/docs/metadata", children: "here" }),
+                " for which metadata is accepted.",
+                jsx_runtime_1.jsx("br", {}),
+                "The parameter must be in the format of ",
+                jsx_runtime_1.jsx("code", { children: "--metadata key=value" }), ' ', "and can be passed multiple times."] }));
+    },
+    docLink: 'https://www.remotion.dev/docs/metadata',
+    type: {},
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            const val = commandLine[cliFlag];
+            const array = typeof val === 'string' ? [val] : val;
+            const keyValues = array.map((a) => {
+                if (!a.includes('=')) {
+                    throw new Error(`"metadata" must be in the format of key=value, but got ${a}`);
+                }
+                const splitted = a.split('=');
+                if (splitted.length !== 2) {
+                    throw new Error(`"metadata" must be in the format of key=value, but got ${a}`);
+                }
+                return [splitted[0], splitted[1]];
+            });
+            const value = Object.fromEntries(keyValues);
+            return {
+                source: 'config',
+                value,
+            };
+        }
+        return {
+            source: 'config',
+            value: metadata,
+        };
+    },
+    setConfig: (newMetadata) => {
+        metadata = newMetadata;
+    },
+    ssrName: 'metadata',
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/mute.d.ts

@@ -0,0 +1,15 @@
+export declare const mutedOption: {
+    name: string;
+    cliFlag: "muted";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: boolean;
+    };
+    setConfig: () => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/mute.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mutedOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const DEFAULT_MUTED_STATE = false;
+let mutedState = DEFAULT_MUTED_STATE;
+const cliFlag = 'muted';
+exports.mutedOption = {
+    name: 'Muted',
+    cliFlag,
+    description: () => jsx_runtime_1.jsx(jsx_runtime_1.Fragment, { children: "The Audio of the video will be omitted." }),
+    ssrName: 'muted',
+    docLink: 'https://www.remotion.dev/docs/audio/muting',
+    type: false,
+    getValue: ({ commandLine }) => {
+        // we set in minimist `muted` default as null
+        if (commandLine[cliFlag] !== null) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (mutedState !== DEFAULT_MUTED_STATE) {
+            return {
+                source: 'config',
+                value: mutedState,
+            };
+        }
+        return {
+            source: 'config',
+            value: mutedState,
+        };
+    },
+    setConfig: () => {
+        mutedState = true;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/number-of-gif-loops.d.ts

@@ -0,0 +1,19 @@
+export type NumberOfGifLoops = number | null;
+export declare const numberOfGifLoopsOption: {
+    name: string;
+    cliFlag: "number-of-gif-loops";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "numberOfGifLoops";
+    docLink: string;
+    type: number | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: number;
+        source: string;
+    } | {
+        value: null;
+        source: string;
+    };
+    setConfig: (newLoop: NumberOfGifLoops) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/number-of-gif-loops.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberOfGifLoopsOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let currentLoop = null;
+const validate = (newLoop) => {
+    if (newLoop !== null && typeof newLoop !== 'number') {
+        throw new Error('--number-of-gif-loops flag must be a number.');
+    }
+};
+const cliFlag = 'number-of-gif-loops';
+exports.numberOfGifLoopsOption = {
+    name: 'Number of GIF loops',
+    cliFlag,
+    description: () => {
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Allows you to set the number of loops as follows:",
+                jsx_runtime_1.jsxs("ul", { children: [
+                        jsx_runtime_1.jsxs("li", { children: [
+                                jsx_runtime_1.jsx("code", { children: "null" }),
+                                " (or omitting in the CLI) plays the GIF indefinitely."] }), jsx_runtime_1.jsxs("li", { children: [
+                                jsx_runtime_1.jsx("code", { children: "0" }),
+                                " disables looping"] }), jsx_runtime_1.jsxs("li", { children: [
+                                jsx_runtime_1.jsx("code", { children: "1" }),
+                                " loops the GIF once (plays twice in total)"] }), jsx_runtime_1.jsxs("li", { children: [
+                                jsx_runtime_1.jsx("code", { children: "2" }),
+                                " loops the GIF twice (plays three times in total) and so on."] })
+                    ] })
+            ] }));
+    },
+    ssrName: 'numberOfGifLoops',
+    docLink: 'https://www.remotion.dev/docs/render-as-gif#changing-the-number-of-loops',
+    type: 0,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            validate(commandLine[cliFlag]);
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        if (currentLoop !== null) {
+            return {
+                value: currentLoop,
+                source: 'config',
+            };
+        }
+        return {
+            value: null,
+            source: 'default',
+        };
+    },
+    setConfig: (newLoop) => {
+        validate(newLoop);
+        currentLoop = newLoop;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/number-of-shared-audio-tags.d.ts

@@ -0,0 +1,15 @@
+export declare const numberOfSharedAudioTagsOption: {
+    name: string;
+    cliFlag: "number-of-shared-audio-tags";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: null;
+    docLink: string;
+    type: number;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: number;
+        source: string;
+    };
+    setConfig(value: number): void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/number-of-shared-audio-tags.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numberOfSharedAudioTagsOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let numberOfSharedAudioTags = 0;
+const cliFlag = 'number-of-shared-audio-tags';
+exports.numberOfSharedAudioTagsOption = {
+    name: 'Number of shared audio tags',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Set number of shared audio tags. See", ' ', jsx_runtime_1.jsx("a", { href: "https://www.remotion.dev/docs/player/autoplay#using-the-numberofsharedaudiotags-prop", children: "Using the numberOfSharedAudioTags prop" }), ' ', "for more information."] })),
+    ssrName: null,
+    docLink: 'https://www.remotion.dev/docs/config#setnumberofsharedaudiotags',
+    type: 0,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                value: commandLine[cliFlag],
+                source: 'cli',
+            };
+        }
+        return {
+            value: numberOfSharedAudioTags,
+            source: 'config',
+        };
+    },
+    setConfig(value) {
+        numberOfSharedAudioTags = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/offthreadvideo-cache-size.d.ts

@@ -0,0 +1,20 @@
+export declare const getOffthreadVideoCacheSizeInBytes: () => number | null;
+export declare const offthreadVideoCacheSizeInBytesOption: {
+    name: string;
+    cliFlag: "offthreadvideo-cache-size-in-bytes";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "offthreadVideoCacheSizeInBytes";
+    docLink: string;
+    type: number | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: number;
+    } | {
+        source: string;
+        value: null;
+    };
+    setConfig: (size: number | null) => void;
+};
+export declare const validateOffthreadVideoCacheSizeInBytes: (option: unknown) => void;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/offthreadvideo-cache-size.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOffthreadVideoCacheSizeInBytes = exports.offthreadVideoCacheSizeInBytesOption = exports.getOffthreadVideoCacheSizeInBytes = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let offthreadVideoCacheSizeInBytes = null;
+const getOffthreadVideoCacheSizeInBytes = () => {
+    return offthreadVideoCacheSizeInBytes;
+};
+exports.getOffthreadVideoCacheSizeInBytes = getOffthreadVideoCacheSizeInBytes;
+const cliFlag = 'offthreadvideo-cache-size-in-bytes';
+exports.offthreadVideoCacheSizeInBytesOption = {
+    name: 'OffthreadVideo cache size',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["From v4.0, Remotion has a cache for", ' ', jsx_runtime_1.jsx("a", { href: "https://remotion.dev/docs/offthreadvideo", children: jsx_runtime_1.jsx("code", { children: "<OffthreadVideo>" }) }), ' ', "frames. The default is ",
+            jsx_runtime_1.jsx("code", { children: "null" }),
+            ", corresponding to half of the system memory available when the render starts.",
+            jsx_runtime_1.jsx("br", {}),
+            " This option allows to override the size of the cache. The higher it is, the faster the render will be, but the more memory will be used.",
+            jsx_runtime_1.jsx("br", {}),
+            "The used value will be printed when running in verbose mode.",
+            jsx_runtime_1.jsx("br", {}),
+            "Default: ",
+            jsx_runtime_1.jsx("code", { children: "null" })
+        ] })),
+    ssrName: 'offthreadVideoCacheSizeInBytes',
+    docLink: 'https://www.remotion.dev/docs/offthreadvideo',
+    type: 0,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (offthreadVideoCacheSizeInBytes !== null) {
+            return {
+                source: 'config',
+                value: offthreadVideoCacheSizeInBytes,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (size) => {
+        offthreadVideoCacheSizeInBytes = size !== null && size !== void 0 ? size : null;
+    },
+};
+const validateOffthreadVideoCacheSizeInBytes = (option) => {
+    if (option === undefined || option === null) {
+        return;
+    }
+    if (typeof option !== 'number') {
+        throw new Error('Expected a number');
+    }
+    if (option < 0 || option === 0) {
+        throw new Error('Expected a positive number');
+    }
+    if (Number.isNaN(option)) {
+        throw new Error('Expected a number');
+    }
+    if (!Number.isFinite(option)) {
+        throw new Error('Expected a finite number');
+    }
+    if (option % 1 !== 0) {
+        throw new Error('Expected a whole number');
+    }
+};
+exports.validateOffthreadVideoCacheSizeInBytes = validateOffthreadVideoCacheSizeInBytes;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/offthreadvideo-threads.d.ts

@@ -0,0 +1,20 @@
+export declare const getOffthreadVideoThreads: () => number | null;
+export declare const offthreadVideoThreadsOption: {
+    name: string;
+    cliFlag: "offthreadvideo-video-threads";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "offthreadVideoThreads";
+    docLink: string;
+    type: number | null;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: number;
+    } | {
+        source: string;
+        value: null;
+    };
+    setConfig: (size: number | null) => void;
+};
+export declare const DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS = 2;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/offthreadvideo-threads.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS = exports.offthreadVideoThreadsOption = exports.getOffthreadVideoThreads = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let value = null;
+const getOffthreadVideoThreads = () => {
+    return value;
+};
+exports.getOffthreadVideoThreads = getOffthreadVideoThreads;
+const cliFlag = 'offthreadvideo-video-threads';
+exports.offthreadVideoThreadsOption = {
+    name: 'OffthreadVideo threads',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["The number of threads that",
+            jsx_runtime_1.jsx("a", { href: "https://remotion.dev/docs/offthreadvideo", children: jsx_runtime_1.jsx("code", { children: "<OffthreadVideo>" }) }), ' ', "can start to extract frames. The default is", ' ', exports.DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS, ". Increase carefully, as too many threads may cause instability."] })),
+    ssrName: 'offthreadVideoThreads',
+    docLink: 'https://www.remotion.dev/docs/offthreadvideo',
+    type: 0,
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (value !== null) {
+            return {
+                source: 'config',
+                value,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (size) => {
+        value = size !== null && size !== void 0 ? size : null;
+    },
+};
+exports.DEFAULT_RENDER_FRAMES_OFFTHREAD_VIDEO_THREADS = 2;

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/on-browser-download.d.ts

@@ -0,0 +1,23 @@
+import type { ChromeMode } from './chrome-mode';
+export type DownloadBrowserProgressFn = (progress: {
+    alreadyAvailable: boolean;
+    percent: number;
+    downloadedBytes: number;
+    totalSizeInBytes: number;
+}) => void;
+export type OnBrowserDownload = (options: {
+    chromeMode: ChromeMode;
+}) => {
+    onProgress: DownloadBrowserProgressFn;
+    version: string | null;
+};
+export declare const onBrowserDownloadOption: {
+    name: string;
+    cliFlag: "on-browser-download";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "onBrowserDownload";
+    docLink: string;
+    type: OnBrowserDownload;
+    getValue: () => never;
+    setConfig: () => never;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/on-browser-download.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onBrowserDownloadOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'on-browser-download';
+exports.onBrowserDownloadOption = {
+    name: 'Browser download callback function',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Gets called when no compatible local browser is detected on the system and this API needs to download a browser. Return a callback to observe progress.", ' ', jsx_runtime_1.jsx("a", { href: "/docs/renderer/ensure-browser#onbrowserdownload", children: "See here for how to use this option." })
+        ] })),
+    ssrName: 'onBrowserDownload',
+    docLink: 'https://www.remotion.dev/docs/renderer/ensure-browser',
+    type: undefined,
+    getValue: () => {
+        throw new Error('does not support config file');
+    },
+    setConfig: () => {
+        throw new Error('does not support config file');
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/option.d.ts

@@ -0,0 +1,20 @@
+import type { TypeOfOption } from '../client';
+export type RemotionOption<SsrName extends string, Type> = {
+    name: string;
+    cliFlag: string;
+    ssrName: SsrName | null;
+    description: (mode: 'ssr' | 'cli') => React.ReactNode;
+    docLink: string | null;
+    type: Type;
+    getValue: (values: {
+        commandLine: Record<string, unknown>;
+    }, more?: any) => {
+        value: Type;
+        source: string;
+    };
+    setConfig: (value: Type) => void;
+};
+export type AnyRemotionOption<T> = RemotionOption<string, T>;
+export type ToOptions<T extends Record<string, AnyRemotionOption<any>>> = {
+    [K in keyof T]: TypeOfOption<T[K]>;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/option.js

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

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/options-map.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optionsMap = void 0;
+const api_key_1 = require("./api-key");
+const audio_bitrate_1 = require("./audio-bitrate");
+const audio_codec_1 = require("./audio-codec");
+const binaries_directory_1 = require("./binaries-directory");
+const chrome_mode_1 = require("./chrome-mode");
+const color_space_1 = require("./color-space");
+const crf_1 = require("./crf");
+const delete_after_1 = require("./delete-after");
+const disallow_parallel_encoding_1 = require("./disallow-parallel-encoding");
+const encoding_buffer_size_1 = require("./encoding-buffer-size");
+const encoding_max_rate_1 = require("./encoding-max-rate");
+const enforce_audio_1 = require("./enforce-audio");
+const for_seamless_aac_concatenation_1 = require("./for-seamless-aac-concatenation");
+const hardware_acceleration_1 = require("./hardware-acceleration");
+const image_sequence_pattern_1 = require("./image-sequence-pattern");
+const jpeg_quality_1 = require("./jpeg-quality");
+const license_key_1 = require("./license-key");
+const log_level_1 = require("./log-level");
+const mute_1 = require("./mute");
+const number_of_gif_loops_1 = require("./number-of-gif-loops");
+const offthreadvideo_cache_size_1 = require("./offthreadvideo-cache-size");
+const offthreadvideo_threads_1 = require("./offthreadvideo-threads");
+const on_browser_download_1 = require("./on-browser-download");
+const prefer_lossless_1 = require("./prefer-lossless");
+const repro_1 = require("./repro");
+const scale_1 = require("./scale");
+const separate_audio_1 = require("./separate-audio");
+const throw_if_site_exists_1 = require("./throw-if-site-exists");
+const timeout_1 = require("./timeout");
+const video_bitrate_1 = require("./video-bitrate");
+const video_cache_size_1 = require("./video-cache-size");
+const video_codec_1 = require("./video-codec");
+const x264_preset_1 = require("./x264-preset");
+exports.optionsMap = {
+    renderMedia: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        videoBitrate: video_bitrate_1.videoBitrateOption,
+        numberOfGifLoops: number_of_gif_loops_1.numberOfGifLoopsOption,
+        repro: repro_1.reproOption,
+        x264Preset: x264_preset_1.x264Option,
+        audioBitrate: audio_bitrate_1.audioBitrateOption,
+        colorSpace: color_space_1.colorSpaceOption,
+        codec: video_codec_1.videoCodecOption,
+        disallowParallelEncoding: disallow_parallel_encoding_1.disallowParallelEncodingOption,
+        jpegQuality: jpeg_quality_1.jpegQualityOption,
+        encodingMaxRate: encoding_max_rate_1.encodingMaxRateOption,
+        encodingBufferSize: encoding_buffer_size_1.encodingBufferSizeOption,
+        muted: mute_1.mutedOption,
+        logLevel: log_level_1.logLevelOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        binariesDirectory: binaries_directory_1.binariesDirectoryOption,
+        forSeamlessAacConcatenation: for_seamless_aac_concatenation_1.forSeamlessAacConcatenationOption,
+        separateAudioTo: separate_audio_1.separateAudioOption,
+        audioCodec: audio_codec_1.audioCodecOption,
+        onBrowserDownload: on_browser_download_1.onBrowserDownloadOption,
+        hardwareAcceleration: hardware_acceleration_1.hardwareAccelerationOption,
+        chromeMode: chrome_mode_1.chromeModeOption,
+        licenseKey: license_key_1.licenseKeyOption,
+    },
+    stitchFramesToVideo: {
+        separateAudioTo: separate_audio_1.separateAudioOption,
+        hardwareAcceleration: hardware_acceleration_1.hardwareAccelerationOption,
+    },
+    renderStill: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        jpegQuality: jpeg_quality_1.jpegQualityOption,
+        logLevel: log_level_1.logLevelOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        binariesDirectory: binaries_directory_1.binariesDirectoryOption,
+        onBrowserDownload: on_browser_download_1.onBrowserDownloadOption,
+        chromeMode: chrome_mode_1.chromeModeOption,
+        apiKey: api_key_1.apiKeyOption,
+        licenseKey: license_key_1.licenseKeyOption,
+    },
+    getCompositions: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        logLevel: log_level_1.logLevelOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        binariesDirectory: binaries_directory_1.binariesDirectoryOption,
+        onBrowserDownload: on_browser_download_1.onBrowserDownloadOption,
+        chromeMode: chrome_mode_1.chromeModeOption,
+    },
+    selectComposition: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        logLevel: log_level_1.logLevelOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        binariesDirectory: binaries_directory_1.binariesDirectoryOption,
+        onBrowserDownload: on_browser_download_1.onBrowserDownloadOption,
+        chromeMode: chrome_mode_1.chromeModeOption,
+    },
+    renderFrames: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        forSeamlessAacConcatenation: for_seamless_aac_concatenation_1.forSeamlessAacConcatenationOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        jpegQuality: jpeg_quality_1.jpegQualityOption,
+        logLevel: log_level_1.logLevelOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        binariesDirectory: binaries_directory_1.binariesDirectoryOption,
+        onBrowserDownload: on_browser_download_1.onBrowserDownloadOption,
+        chromeMode: chrome_mode_1.chromeModeOption,
+        imageSequencePattern: image_sequence_pattern_1.imageSequencePatternOption,
+    },
+    renderMediaOnLambda: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        videoBitrate: video_bitrate_1.videoBitrateOption,
+        numberOfGifLoops: number_of_gif_loops_1.numberOfGifLoopsOption,
+        preferLossless: prefer_lossless_1.preferLosslessAudioOption,
+        audioBitrate: audio_bitrate_1.audioBitrateOption,
+        deleteAfter: delete_after_1.deleteAfterOption,
+        x264Preset: x264_preset_1.x264Option,
+        encodingMaxRate: encoding_max_rate_1.encodingMaxRateOption,
+        encodingBufferSize: encoding_buffer_size_1.encodingBufferSizeOption,
+        colorSpace: color_space_1.colorSpaceOption,
+        muted: mute_1.mutedOption,
+        logLevel: log_level_1.logLevelOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        apiKey: api_key_1.apiKeyOption,
+        licenseKey: license_key_1.licenseKeyOption,
+    },
+    renderStillOnLambda: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        jpegQuality: jpeg_quality_1.jpegQualityOption,
+        logLevel: log_level_1.logLevelOption,
+        deleteAfter: delete_after_1.deleteAfterOption,
+        scale: scale_1.scaleOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        apiKey: api_key_1.apiKeyOption,
+        licenseKey: license_key_1.licenseKeyOption,
+    },
+    getCompositionsOnLambda: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        logLevel: log_level_1.logLevelOption,
+        timeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+    },
+    renderMediaOnCloudRun: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        numberOfGifLoops: number_of_gif_loops_1.numberOfGifLoopsOption,
+        preferLossless: prefer_lossless_1.preferLosslessAudioOption,
+        colorSpace: color_space_1.colorSpaceOption,
+        audioBitrate: audio_bitrate_1.audioBitrateOption,
+        videoBitrate: video_bitrate_1.videoBitrateOption,
+        x264Preset: x264_preset_1.x264Option,
+        encodingMaxRate: encoding_max_rate_1.encodingMaxRateOption,
+        encodingBufferSize: encoding_buffer_size_1.encodingBufferSizeOption,
+        muted: mute_1.mutedOption,
+        logLevel: log_level_1.logLevelOption,
+        delayRenderTimeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+        enforceAudioTrack: enforce_audio_1.enforceAudioOption,
+        scale: scale_1.scaleOption,
+        crf: crf_1.crfOption,
+        jpegQuality: jpeg_quality_1.jpegQualityOption,
+    },
+    renderStillOnCloudRun: {
+        mediaCacheSizeInBytes: video_cache_size_1.mediaCacheSizeInBytesOption,
+        offthreadVideoCacheSizeInBytes: offthreadvideo_cache_size_1.offthreadVideoCacheSizeInBytesOption,
+        offthreadVideoThreads: offthreadvideo_threads_1.offthreadVideoThreadsOption,
+        logLevel: log_level_1.logLevelOption,
+        scale: scale_1.scaleOption,
+        jpegQuality: jpeg_quality_1.jpegQualityOption,
+        delayRenderTimeoutInMilliseconds: timeout_1.delayRenderTimeoutInMillisecondsOption,
+    },
+    ensureBrowser: {
+        logLevel: log_level_1.logLevelOption,
+        onBrowserDownload: on_browser_download_1.onBrowserDownloadOption,
+        chromeMode: chrome_mode_1.chromeModeOption,
+    },
+    openBrowser: {
+        logLevel: log_level_1.logLevelOption,
+        onBrowserDownload: on_browser_download_1.onBrowserDownloadOption,
+        chromeMode: chrome_mode_1.chromeModeOption,
+    },
+    deploySiteLambda: {
+        logLevel: log_level_1.logLevelOption,
+        throwIfSiteExists: throw_if_site_exists_1.throwIfSiteExistsOption,
+    },
+    deploySiteCloudRun: {
+        logLevel: log_level_1.logLevelOption,
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/overwrite.d.ts

@@ -0,0 +1,15 @@
+export declare const overwriteOption: {
+    name: string;
+    cliFlag: "overwrite";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: string;
+    docLink: string;
+    type: boolean;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }, defaultValue: boolean) => {
+        source: string;
+        value: boolean;
+    };
+    setConfig: (value: boolean) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/overwrite.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwriteOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+let shouldOverwrite = null;
+const cliFlag = 'overwrite';
+const validate = (value) => {
+    if (typeof value !== 'boolean') {
+        throw new Error(`overwriteExisting must be a boolean but got ${typeof value} (${value})`);
+    }
+};
+exports.overwriteOption = {
+    name: 'Overwrite output',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["If set to ",
+            jsx_runtime_1.jsx("code", { children: "false" }),
+            ", will prevent rendering to a path that already exists. Default is ",
+            jsx_runtime_1.jsx("code", { children: "true" }),
+            "."] })),
+    ssrName: 'overwrite',
+    docLink: 'https://www.remotion.dev/docs/config#setoverwriteoutput',
+    type: false,
+    getValue: ({ commandLine }, defaultValue) => {
+        if (commandLine[cliFlag] !== undefined) {
+            validate(commandLine[cliFlag]);
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (shouldOverwrite !== null) {
+            return {
+                source: 'config',
+                value: shouldOverwrite,
+            };
+        }
+        return {
+            source: 'default',
+            value: defaultValue,
+        };
+    },
+    setConfig: (value) => {
+        validate(value);
+        shouldOverwrite = value;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/prefer-lossless.d.ts

@@ -0,0 +1,18 @@
+export declare const preferLosslessAudioOption: {
+    name: string;
+    cliFlag: "prefer-lossless";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    docLink: string;
+    type: boolean;
+    ssrName: "preferLossless";
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        value: true;
+        source: string;
+    } | {
+        value: false;
+        source: string;
+    };
+    setConfig: (val: boolean) => void;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/prefer-lossless.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferLosslessAudioOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'prefer-lossless';
+let input = false;
+exports.preferLosslessAudioOption = {
+    name: 'Prefer lossless',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Uses a lossless audio codec, if one is available for the codec. If you set",
+            jsx_runtime_1.jsx("code", { children: "audioCodec" }),
+            ", it takes priority over", ' ', jsx_runtime_1.jsx("code", { children: "preferLossless" }),
+            "."] })),
+    docLink: 'https://www.remotion.dev/docs/encoding',
+    type: false,
+    ssrName: 'preferLossless',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag]) {
+            return { value: true, source: 'cli' };
+        }
+        if (input === true) {
+            return { value: true, source: 'config' };
+        }
+        return { value: false, source: 'default' };
+    },
+    setConfig: (val) => {
+        input = val;
+    },
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/private-license-key.d.ts

@@ -0,0 +1,15 @@
+export declare const privateLicenseKeyOption: {
+    name: string;
+    cliFlag: "private-license-key";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "privateLicenseKey";
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (value: string | null) => void;
+    type: string | null;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/private-license-key.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.privateLicenseKeyOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'private-license-key';
+let currentPrivateLicenseKey = null;
+exports.privateLicenseKeyOption = {
+    name: 'Private License Key',
+    cliFlag,
+    description: () => ((0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: ["The private license key for your company license, obtained from the \"Usage\" tab on ", (0, jsx_runtime_1.jsx)("a", { href: "https://remotion.pro/dashboard", children: "remotion.pro" }), ". If you are eligible for the free license, pass \"free-license\"."] })),
+    ssrName: 'privateLicenseKey',
+    docLink: 'https://www.remotion.dev/docs/licensing',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentPrivateLicenseKey !== null) {
+            return {
+                source: 'config',
+                value: currentPrivateLicenseKey,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        currentPrivateLicenseKey = value;
+    },
+    type: null,
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/public-dir.d.ts

@@ -0,0 +1,18 @@
+export declare const publicDirOption: {
+    name: string;
+    cliFlag: "public-dir";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "publicDir";
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string;
+    } | {
+        source: string;
+        value: null;
+    };
+    setConfig: (value: string | null) => void;
+    type: string | null;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/public-dir.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicDirOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'public-dir';
+let currentPublicDir = null;
+exports.publicDirOption = {
+    name: 'Public Directory',
+    cliFlag,
+    description: () => {
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["Define the location of the", ' ', jsx_runtime_1.jsx("a", { href: "/docs/terminology/public-dir", children: jsx_runtime_1.jsx("code", { children: "public/ directory" }) }),
+                ". If not defined, Remotion will assume the location is the `public` folder in your Remotion root."] }));
+    },
+    ssrName: 'publicDir',
+    docLink: 'https://www.remotion.dev/docs/terminology/public-dir',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentPublicDir !== null) {
+            return {
+                source: 'config',
+                value: currentPublicDir,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        currentPublicDir = value;
+    },
+    type: '',
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/public-license-key.d.ts

@@ -0,0 +1,15 @@
+export declare const publicLicenseKeyOption: {
+    name: string;
+    cliFlag: "public-license-key";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "publicLicenseKey";
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string | null;
+    };
+    setConfig: (value: string | null) => void;
+    type: string | null;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/public-license-key.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicLicenseKeyOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'public-license-key';
+let currentPublicLicenseKey = null;
+exports.publicLicenseKeyOption = {
+    name: 'Public License Key',
+    cliFlag,
+    description: () => (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["The public license key for your company license, obtained from the \"Usage\" tab on ",
+            jsx_runtime_1.jsx("a", { href: "https://remotion.pro/dashboard", children: "remotion.pro" }),
+            ". If you are eligible for the free license, pass \"free-license\"."] })),
+    ssrName: 'publicLicenseKey',
+    docLink: 'https://www.remotion.dev/docs/licensing',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentPublicLicenseKey !== null) {
+            return {
+                source: 'config',
+                value: currentPublicLicenseKey,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        if (value && value !== 'free-license' && !value.startsWith('rm_pub_')) {
+            throw new Error('Invalid public license key. It must start with "rm_pub_" or be "free-license".');
+        }
+        currentPublicLicenseKey = value;
+    },
+    type: null,
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/public-path.d.ts

@@ -0,0 +1,18 @@
+export declare const publicPathOption: {
+    name: string;
+    cliFlag: "public-path";
+    description: () => import("react/jsx-runtime").JSX.Element;
+    ssrName: "publicPath";
+    docLink: string;
+    getValue: ({ commandLine }: {
+        commandLine: Record<string, unknown>;
+    }) => {
+        source: string;
+        value: string;
+    } | {
+        source: string;
+        value: null;
+    };
+    setConfig: (value: string | null) => void;
+    type: string | null;
+};

skills/remotion-prompt-video/node_modules/@remotion/renderer/dist/options/public-path.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicPathOption = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const cliFlag = 'public-path';
+let currentPublicPath = null;
+exports.publicPathOption = {
+    name: 'Public Path',
+    cliFlag,
+    description: () => {
+        return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: ["The path of the URL where the bundle is going to be hosted. By default it is ",
+                jsx_runtime_1.jsx("code", { children: "/" }),
+                ", meaning that the bundle is going to be hosted at the root of the domain (e.g. ",
+                jsx_runtime_1.jsx("code", { children: "https://localhost:3000/" }),
+                "). If you are deploying to a subdirectory (e.g. ",
+                jsx_runtime_1.jsx("code", { children: "/sites/my-site/" }),
+                "), you should set this to the subdirectory."] }));
+    },
+    ssrName: 'publicPath',
+    docLink: 'https://www.remotion.dev/docs/renderer',
+    getValue: ({ commandLine }) => {
+        if (commandLine[cliFlag] !== undefined) {
+            return {
+                source: 'cli',
+                value: commandLine[cliFlag],
+            };
+        }
+        if (currentPublicPath !== null) {
+            return {
+                source: 'config',
+                value: currentPublicPath,
+            };
+        }
+        return {
+            source: 'default',
+            value: null,
+        };
+    },
+    setConfig: (value) => {
+        currentPublicPath = value;
+    },
+    type: '',
+};