@mevdragon/vidfarm-devcli 0.5.3 → 0.6.0

package/dist/src/services/media-processing.js

@@ -0,0 +1,766 @@
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import ffmpegPath from "ffmpeg-static";
+import ffprobe from "ffprobe-static";
+const DEFAULT_MAX_WIDTH = 1080;
+const DEFAULT_MAX_HEIGHT = 1920;
+const DEFAULT_CRF = 23;
+const DEFAULT_MAX_VIDEO_BITRATE_KBPS = 8_000;
+const DEFAULT_AUDIO_BITRATE_KBPS = 128;
+const DEFAULT_AUDIO_SAMPLE_RATE = 48_000;
+// Hard cap on probeable media duration. Every downstream consumer of
+// probeMediaAsset (auto-decompose, ingest, primitive video_probe / audio_probe)
+// is metered on downstream compute — a caller probing hour-long videos in a
+// loop is disproportionately expensive relative to REST rate limits. Enforced
+// inside the probe itself so no call site can accidentally bypass it.
+export const MAX_PROBE_DURATION_SECONDS = 120;
+export class MediaDurationExceededError extends Error {
+    durationSeconds;
+    maxDurationSeconds;
+    constructor(durationSeconds, maxDurationSeconds) {
+        super(`Media duration ${durationSeconds.toFixed(1)}s exceeds ${maxDurationSeconds}s limit`);
+        this.name = "MediaDurationExceededError";
+        this.durationSeconds = durationSeconds;
+        this.maxDurationSeconds = maxDurationSeconds;
+    }
+}
+const resolvedFfmpegPath = typeof ffmpegPath === "string" && ffmpegPath.trim() ? ffmpegPath : "ffmpeg";
+const ffprobePath = typeof ffprobe.path === "string" ? ffprobe.path : "";
+const resolvedFfprobePath = ffprobePath.trim() ? ffprobePath : "ffprobe";
+export function estimateNormalizationCostUsd(metadata) {
+    const durationSeconds = Math.max(metadata.source.durationSeconds ?? 0, metadata.normalized.durationSeconds ?? 0);
+    const largerFootprintMb = Math.max(metadata.source.bytes, metadata.normalized.bytes) / (1024 * 1024);
+    const estimated = 0.003 + (durationSeconds * 0.0001) + (largerFootprintMb * 0.00005);
+    return Number(estimated.toFixed(4));
+}
+export async function probeMediaAsset(input) {
+    const maxDurationSeconds = input.maxDurationSeconds ?? MAX_PROBE_DURATION_SECONDS;
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-media-probe-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const metadata = await ffprobeMedia(sourcePath);
+        const durationSeconds = metadata.durationSeconds;
+        if (Number.isFinite(durationSeconds) &&
+            durationSeconds !== null &&
+            durationSeconds > maxDurationSeconds) {
+            throw new MediaDurationExceededError(durationSeconds, maxDurationSeconds);
+        }
+        return {
+            metadata: {
+                ...metadata,
+                bytes: sourceBytes,
+                url: input.sourceUrl,
+                contentType: inferContentTypeFromPath(sourcePath, metadata)
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function normalizeVideoAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-video-normalize-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    const outputPath = path.join(tempDir, "normalized.mp4");
+    const preset = input.preset ?? "veryfast";
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const sourceProbe = await ffprobeMedia(sourcePath);
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            "-i", sourcePath,
+            "-map", "0:v:0",
+            "-map", "0:a:0?",
+            "-vf", buildNormalizationVideoFilter({
+                width: sourceProbe.width,
+                height: sourceProbe.height,
+                maxWidth: input.maxWidth ?? DEFAULT_MAX_WIDTH,
+                maxHeight: input.maxHeight ?? DEFAULT_MAX_HEIGHT
+            }),
+            "-c:v", "libx264",
+            "-preset", preset,
+            "-crf", String(input.crf ?? DEFAULT_CRF),
+            "-maxrate", `${input.maxVideoBitrateKbps ?? DEFAULT_MAX_VIDEO_BITRATE_KBPS}k`,
+            "-bufsize", `${(input.maxVideoBitrateKbps ?? DEFAULT_MAX_VIDEO_BITRATE_KBPS) * 2}k`,
+            "-pix_fmt", "yuv420p",
+            "-movflags", "+faststart",
+            "-g", "60",
+            "-keyint_min", "60",
+            "-sc_threshold", "0",
+            "-c:a", "aac",
+            "-b:a", `${input.audioBitrateKbps ?? DEFAULT_AUDIO_BITRATE_KBPS}k`,
+            "-ar", String(DEFAULT_AUDIO_SAMPLE_RATE),
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        const normalizedProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: "video/mp4",
+            metadata: {
+                source: {
+                    ...sourceProbe,
+                    bytes: sourceBytes,
+                    url: input.sourceUrl
+                },
+                normalized: {
+                    ...normalizedProbe,
+                    bytes: outputBytes.byteLength
+                },
+                compressionRatio: sourceBytes > 0 ? outputBytes.byteLength / sourceBytes : null
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function trimVideoAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-video-trim-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    const outputPath = path.join(tempDir, "trimmed.mp4");
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const sourceProbe = await ffprobeMedia(sourcePath);
+        const clip = resolveTimeWindow(input);
+        const startSeconds = clip.startMs / 1000;
+        const durationSeconds = clip.durationMs / 1000;
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            "-ss", formatSeconds(startSeconds),
+            "-i", sourcePath,
+            "-t", formatSeconds(durationSeconds),
+            "-map", "0:v:0",
+            "-map", "0:a:0?",
+            "-vf", buildNormalizationVideoFilter({
+                width: sourceProbe.width,
+                height: sourceProbe.height,
+                maxWidth: input.maxWidth ?? sourceProbe.width ?? DEFAULT_MAX_WIDTH,
+                maxHeight: input.maxHeight ?? sourceProbe.height ?? DEFAULT_MAX_HEIGHT
+            }),
+            "-c:v", "libx264",
+            "-preset", input.preset ?? "veryfast",
+            "-crf", String(input.crf ?? DEFAULT_CRF),
+            "-pix_fmt", "yuv420p",
+            "-movflags", "+faststart",
+            "-c:a", "aac",
+            "-b:a", `${input.audioBitrateKbps ?? DEFAULT_AUDIO_BITRATE_KBPS}k`,
+            "-ar", String(DEFAULT_AUDIO_SAMPLE_RATE),
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        const trimmedProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: "video/mp4",
+            metadata: {
+                source: { ...sourceProbe, bytes: sourceBytes, url: input.sourceUrl },
+                trimmed: { ...trimmedProbe, bytes: outputBytes.byteLength },
+                startMs: clip.startMs,
+                durationMs: clip.durationMs,
+                endMs: clip.startMs + clip.durationMs
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function extractAudioFromVideoAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-extract-audio-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    const format = input.format ?? "mp3";
+    const outputPath = path.join(tempDir, `audio.${audioExtension(format)}`);
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const sourceProbe = await ffprobeMedia(sourcePath);
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            "-i", sourcePath,
+            "-vn",
+            ...audioEncodeArgs(format, input.bitrateKbps),
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: audioContentType(format),
+            metadata: {
+                source: { ...sourceProbe, bytes: sourceBytes, url: input.sourceUrl },
+                extracted: { ...outputProbe, bytes: outputBytes.byteLength },
+                format
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function trimAudioAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-audio-trim-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    const format = input.format ?? "mp3";
+    const outputPath = path.join(tempDir, `trimmed.${audioExtension(format)}`);
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const sourceProbe = await ffprobeMedia(sourcePath);
+        const clip = resolveTimeWindow(input);
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            "-ss", formatSeconds(clip.startMs / 1000),
+            "-i", sourcePath,
+            "-t", formatSeconds(clip.durationMs / 1000),
+            ...audioEncodeArgs(format, input.bitrateKbps),
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: audioContentType(format),
+            metadata: {
+                source: { ...sourceProbe, bytes: sourceBytes, url: input.sourceUrl },
+                trimmed: { ...outputProbe, bytes: outputBytes.byteLength },
+                startMs: clip.startMs,
+                durationMs: clip.durationMs,
+                endMs: clip.startMs + clip.durationMs,
+                format
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function normalizeAudioAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-audio-normalize-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    const format = input.format ?? "mp3";
+    const outputPath = path.join(tempDir, `normalized.${audioExtension(format)}`);
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const sourceProbe = await ffprobeMedia(sourcePath);
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            "-i", sourcePath,
+            "-af", "loudnorm=I=-16:LRA=11:TP=-1.5",
+            ...audioEncodeArgs(format, input.bitrateKbps, input.sampleRateHz ?? DEFAULT_AUDIO_SAMPLE_RATE),
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: audioContentType(format),
+            metadata: {
+                source: { ...sourceProbe, bytes: sourceBytes, url: input.sourceUrl },
+                normalized: { ...outputProbe, bytes: outputBytes.byteLength },
+                format
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function muteVideoAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-video-mute-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    const outputPath = path.join(tempDir, "muted.mp4");
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const sourceProbe = await ffprobeMedia(sourcePath);
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            "-i", sourcePath,
+            "-map", "0:v:0",
+            "-an",
+            "-c:v", "copy",
+            "-movflags", "+faststart",
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: "video/mp4",
+            metadata: {
+                source: { ...sourceProbe, bytes: sourceBytes, url: input.sourceUrl },
+                muted: { ...outputProbe, bytes: outputBytes.byteLength }
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function replaceVideoAudioAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-video-replace-audio-"));
+    const videoPath = path.join(tempDir, "video.bin");
+    const audioPath = path.join(tempDir, "audio.bin");
+    const outputPath = path.join(tempDir, "output.mp4");
+    try {
+        const videoBytes = await downloadUrlToFile(input.sourceVideoUrl, videoPath);
+        const audioBytes = await downloadUrlToFile(input.audioUrl, audioPath);
+        const videoProbe = await ffprobeMedia(videoPath);
+        const audioProbe = await ffprobeMedia(audioPath);
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            "-i", videoPath,
+            "-i", audioPath,
+            "-map", "0:v:0",
+            "-map", "1:a:0",
+            "-c:v", "copy",
+            "-c:a", "aac",
+            "-b:a", `${input.audioBitrateKbps ?? DEFAULT_AUDIO_BITRATE_KBPS}k`,
+            "-shortest",
+            "-movflags", "+faststart",
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: "video/mp4",
+            metadata: {
+                sourceVideo: { ...videoProbe, bytes: videoBytes, url: input.sourceVideoUrl },
+                sourceAudio: { ...audioProbe, bytes: audioBytes, url: input.audioUrl },
+                replaced: { ...outputProbe, bytes: outputBytes.byteLength }
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function extractVideoFrameAsset(input) {
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-video-frame-"));
+    const sourcePath = path.join(tempDir, "source.bin");
+    const format = input.format ?? "png";
+    const outputPath = path.join(tempDir, `frame.${format === "jpeg" ? "jpg" : format}`);
+    try {
+        const sourceBytes = await downloadUrlToFile(input.sourceUrl, sourcePath);
+        const sourceProbe = await ffprobeMedia(sourcePath);
+        await runFfmpeg([
+            "-hide_banner",
+            "-y",
+            ...(typeof input.atMs === "number" && input.atMs > 0 ? ["-ss", formatSeconds(input.atMs / 1000)] : []),
+            "-i", sourcePath,
+            "-frames:v", "1",
+            outputPath
+        ]);
+        const outputBytes = await readFile(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: format === "jpeg" ? "image/jpeg" : "image/png",
+            metadata: {
+                source: { ...sourceProbe, bytes: sourceBytes, url: input.sourceUrl },
+                atMs: Math.max(0, Math.round(input.atMs ?? 0)),
+                format
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function concatAudioAssets(input) {
+    if (!input.sourceUrls.length) {
+        throw new Error("At least one audio source URL is required.");
+    }
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-audio-concat-"));
+    const format = input.format ?? "mp3";
+    const outputPath = path.join(tempDir, `concat.${audioExtension(format)}`);
+    try {
+        const inputs = [];
+        for (let index = 0; index < input.sourceUrls.length; index += 1) {
+            const filePath = path.join(tempDir, `audio-${String(index + 1).padStart(3, "0")}.bin`);
+            const bytes = await downloadUrlToFile(input.sourceUrls[index], filePath);
+            const metadata = await ffprobeMedia(filePath);
+            inputs.push({ url: input.sourceUrls[index], filePath, bytes, metadata });
+        }
+        const args = ["-hide_banner", "-y"];
+        for (const item of inputs) {
+            args.push("-i", item.filePath);
+        }
+        const filterInputs = inputs.map((_, index) => `[${index}:a]`).join("");
+        args.push("-filter_complex", `${filterInputs}concat=n=${inputs.length}:v=0:a=1[outa]`, "-map", "[outa]", ...audioEncodeArgs(format, input.bitrateKbps), outputPath);
+        await runFfmpeg(args);
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: audioContentType(format),
+            metadata: {
+                sources: inputs.map((item) => ({ ...item.metadata, bytes: item.bytes, url: item.url })),
+                concatenated: { ...outputProbe, bytes: outputBytes.byteLength },
+                format,
+                sourceCount: inputs.length
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function concatVideoAssets(input) {
+    if (!input.sourceUrls.length) {
+        throw new Error("At least one video source URL is required.");
+    }
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-video-concat-"));
+    const outputPath = path.join(tempDir, "concat.mp4");
+    try {
+        const inputs = [];
+        for (let index = 0; index < input.sourceUrls.length; index += 1) {
+            const filePath = path.join(tempDir, `video-${String(index + 1).padStart(3, "0")}.bin`);
+            const bytes = await downloadUrlToFile(input.sourceUrls[index], filePath);
+            const metadata = await ffprobeMedia(filePath);
+            inputs.push({ url: input.sourceUrls[index], filePath, bytes, metadata });
+        }
+        const width = Math.max(16, Math.round(input.width ?? inputs[0]?.metadata.width ?? DEFAULT_MAX_WIDTH));
+        const height = Math.max(16, Math.round(input.height ?? inputs[0]?.metadata.height ?? DEFAULT_MAX_HEIGHT));
+        const fit = input.fit ?? "contain";
+        const backgroundColor = normalizeFfmpegColor(input.backgroundColor || "black");
+        const args = ["-hide_banner", "-y"];
+        for (const item of inputs) {
+            args.push("-i", item.filePath);
+        }
+        const filters = inputs.map((_, index) => (`[${index}:v]${videoCanvasFilter({ width, height, fit, backgroundColor })}[v${index}]`));
+        const concatInputs = inputs.map((_, index) => `[v${index}]`).join("");
+        args.push("-filter_complex", `${filters.join(";")};${concatInputs}concat=n=${inputs.length}:v=1:a=0[outv]`, "-map", "[outv]", "-an", "-r", "30", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-movflags", "+faststart", outputPath);
+        await runFfmpeg(args);
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: "video/mp4",
+            metadata: {
+                sources: inputs.map((item) => ({ ...item.metadata, bytes: item.bytes, url: item.url })),
+                concatenated: { ...outputProbe, bytes: outputBytes.byteLength },
+                width,
+                height,
+                fit,
+                sourceCount: inputs.length,
+                includesAudio: false
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+export async function renderSlidesVideoAsset(input) {
+    if (!input.slides.length) {
+        throw new Error("At least one slide is required.");
+    }
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "vidfarm-primitive-slides-"));
+    const outputPath = path.join(tempDir, "output.mp4");
+    try {
+        const downloadedSlides = [];
+        for (let index = 0; index < input.slides.length; index += 1) {
+            const slide = input.slides[index];
+            const filePath = path.join(tempDir, `slide-${String(index + 1).padStart(3, "0")}${extensionForMediaUrl(slide.mediaUrl, slide.mediaType)}`);
+            await downloadMediaToFile(slide.mediaUrl, filePath);
+            downloadedSlides.push({ ...slide, filePath });
+        }
+        await runFfmpeg(buildSlideRenderArgs({
+            slides: downloadedSlides,
+            outputPath,
+            width: input.width,
+            height: input.height,
+            backgroundColor: input.backgroundColor,
+            defaultFit: input.defaultFit
+        }));
+        const outputBytes = await readFile(outputPath);
+        const outputProbe = await ffprobeMedia(outputPath);
+        return {
+            bytes: outputBytes,
+            contentType: "video/mp4",
+            metadata: {
+                rendered: { ...outputProbe, bytes: outputBytes.byteLength },
+                width: input.width,
+                height: input.height,
+                slideCount: input.slides.length,
+                durationMs: input.slides.reduce((sum, slide) => sum + slide.durationMs, 0)
+            }
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+function buildNormalizationVideoFilter(input) {
+    const width = input.width ?? input.maxWidth;
+    const height = input.height ?? input.maxHeight;
+    if (width <= input.maxWidth && height <= input.maxHeight) {
+        return "scale=trunc(iw/2)*2:trunc(ih/2)*2,setsar=1";
+    }
+    return `scale=w=${input.maxWidth}:h=${input.maxHeight}:force_original_aspect_ratio=decrease:force_divisible_by=2,setsar=1`;
+}
+function resolveTimeWindow(input) {
+    const startMs = Math.max(0, Math.round(input.startMs ?? 0));
+    const durationMs = input.durationMs == null
+        ? Math.max(1, Math.round((input.endMs ?? 0) - startMs))
+        : Math.max(1, Math.round(input.durationMs));
+    if (input.durationMs == null && (input.endMs == null || input.endMs <= startMs)) {
+        throw new Error("Provide either durationMs or an endMs greater than startMs.");
+    }
+    return {
+        startMs,
+        durationMs
+    };
+}
+function audioEncodeArgs(format, bitrateKbps, sampleRateHz = DEFAULT_AUDIO_SAMPLE_RATE) {
+    if (format === "wav") {
+        return ["-c:a", "pcm_s16le", "-ar", String(sampleRateHz)];
+    }
+    if (format === "m4a") {
+        return ["-c:a", "aac", "-b:a", `${bitrateKbps ?? DEFAULT_AUDIO_BITRATE_KBPS}k`, "-ar", String(sampleRateHz)];
+    }
+    return ["-c:a", "libmp3lame", "-b:a", `${bitrateKbps ?? DEFAULT_AUDIO_BITRATE_KBPS}k`, "-ar", String(sampleRateHz)];
+}
+function audioContentType(format) {
+    if (format === "wav")
+        return "audio/wav";
+    if (format === "m4a")
+        return "audio/mp4";
+    return "audio/mpeg";
+}
+function audioExtension(format) {
+    if (format === "wav")
+        return "wav";
+    if (format === "m4a")
+        return "m4a";
+    return "mp3";
+}
+function videoCanvasFilter(input) {
+    if (input.fit === "fill") {
+        return `scale=${input.width}:${input.height},setsar=1,fps=30,setpts=PTS-STARTPTS`;
+    }
+    if (input.fit === "contain") {
+        return `scale=${input.width}:${input.height}:force_original_aspect_ratio=decrease,pad=${input.width}:${input.height}:(ow-iw)/2:(oh-ih)/2:color=${input.backgroundColor},setsar=1,fps=30,setpts=PTS-STARTPTS`;
+    }
+    return `scale=${input.width}:${input.height}:force_original_aspect_ratio=increase,crop=${input.width}:${input.height},setsar=1,fps=30,setpts=PTS-STARTPTS`;
+}
+function buildSlideRenderArgs(input) {
+    const args = ["-hide_banner", "-y"];
+    for (const slide of input.slides) {
+        const durationSeconds = slide.durationMs / 1000;
+        if (slide.mediaType === "video") {
+            args.push("-stream_loop", "-1", "-t", durationSeconds.toFixed(3), "-i", slide.filePath);
+        }
+        else {
+            args.push("-loop", "1", "-t", durationSeconds.toFixed(3), "-i", slide.filePath);
+        }
+    }
+    const filters = input.slides.map((slide, index) => {
+        const durationSeconds = slide.durationMs / 1000;
+        const fit = slide.fit ?? input.defaultFit;
+        const backgroundColor = normalizeFfmpegColor(slide.backgroundColor || input.backgroundColor);
+        return `[${index}:v]${primitiveSlideVideoFilter({
+            width: input.width,
+            height: input.height,
+            fit,
+            backgroundColor,
+            durationSeconds
+        })}[v${index}]`;
+    });
+    const concatInputs = input.slides.map((_, index) => `[v${index}]`).join("");
+    const filterComplex = `${filters.join(";")};${concatInputs}concat=n=${input.slides.length}:v=1:a=0[outv]`;
+    args.push("-filter_complex", filterComplex, "-map", "[outv]", "-an", "-r", "30", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-movflags", "+faststart", input.outputPath);
+    return args;
+}
+function primitiveSlideVideoFilter(input) {
+    const base = input.fit === "fill"
+        ? `scale=${input.width}:${input.height}`
+        : input.fit === "contain"
+            ? `scale=${input.width}:${input.height}:force_original_aspect_ratio=decrease,pad=${input.width}:${input.height}:(ow-iw)/2:(oh-ih)/2:color=${input.backgroundColor}`
+            : `scale=${input.width}:${input.height}:force_original_aspect_ratio=increase,crop=${input.width}:${input.height}`;
+    return `${base},setsar=1,fps=30,trim=duration=${input.durationSeconds.toFixed(3)},setpts=PTS-STARTPTS`;
+}
+async function downloadMediaToFile(url, filePath) {
+    const response = await fetch(url, { signal: AbortSignal.timeout(60_000) });
+    if (!response.ok) {
+        throw new Error(`Media returned ${response.status} ${response.statusText || "HTTP error"} for ${formatUrlForError(url)}`);
+    }
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (!bytes.byteLength) {
+        throw new Error(`Media was empty for ${formatUrlForError(url)}`);
+    }
+    await writeFile(filePath, bytes);
+}
+export async function ffprobeMedia(filePath) {
+    const stdout = await runCommand(resolvedFfprobePath, [
+        "-v", "error",
+        "-print_format", "json",
+        "-show_streams",
+        "-show_format",
+        filePath
+    ]);
+    const parsed = JSON.parse(stdout);
+    const streams = Array.isArray(parsed.streams) ? parsed.streams : [];
+    const video = streams.find((stream) => stream.codec_type === "video") ?? null;
+    const audio = streams.find((stream) => stream.codec_type === "audio") ?? null;
+    const format = parsed.format ?? {};
+    return {
+        durationSeconds: parseNullableNumber(format.duration),
+        width: parseNullableInteger(video?.width),
+        height: parseNullableInteger(video?.height),
+        videoCodec: typeof video?.codec_name === "string" ? video.codec_name : null,
+        audioCodec: typeof audio?.codec_name === "string" ? audio.codec_name : null,
+        videoBitrateKbps: toKbps(parseNullableNumber(video?.bit_rate)),
+        audioBitrateKbps: toKbps(parseNullableNumber(audio?.bit_rate)),
+        formatBitrateKbps: toKbps(parseNullableNumber(format.bit_rate)),
+        hasAudio: Boolean(audio),
+        hasVideo: Boolean(video),
+        sampleRateHz: parseNullableInteger(audio?.sample_rate),
+        channels: parseNullableInteger(audio?.channels),
+        frameRate: parseFrameRate(video?.avg_frame_rate ?? video?.r_frame_rate),
+        formatName: typeof format.format_name === "string" ? format.format_name : null
+    };
+}
+async function downloadUrlToFile(url, filePath) {
+    const response = await fetch(url, { signal: AbortSignal.timeout(10 * 60 * 1000) });
+    if (!response.ok) {
+        throw new Error(`Media download returned ${response.status} ${response.statusText || "HTTP error"} for ${formatUrlForError(url)}`);
+    }
+    if (!response.body) {
+        throw new Error(`Media download returned no body for ${formatUrlForError(url)}`);
+    }
+    const source = Readable.fromWeb(response.body);
+    const sink = createWriteStream(filePath);
+    await pipeline(source, sink);
+    const bytes = Number.parseInt(response.headers.get("content-length") || "", 10);
+    if (Number.isFinite(bytes) && bytes > 0) {
+        return bytes;
+    }
+    const written = await readFile(filePath);
+    return written.byteLength;
+}
+export async function runFfmpeg(args) {
+    await runCommand(resolvedFfmpegPath, args, true);
+}
+async function runCommand(command, args, allowStderr = false) {
+    const result = await new Promise((resolve, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+            if (stdout.length > 200_000)
+                stdout = stdout.slice(-200_000);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+            if (stderr.length > 100_000)
+                stderr = stderr.slice(-100_000);
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve({ code, stdout, stderr }));
+    });
+    if (result.code !== 0) {
+        throw new Error(`${path.basename(command)} failed with exit code ${result.code ?? "unknown"}: ${result.stderr.slice(-4000)}`);
+    }
+    if (!allowStderr && result.stderr.trim()) {
+        return result.stdout;
+    }
+    return result.stdout;
+}
+function parseNullableNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function parseNullableInteger(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return Math.trunc(value);
+    if (typeof value === "string") {
+        const parsed = Number.parseInt(value, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function parseFrameRate(value) {
+    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        return value;
+    }
+    if (typeof value !== "string" || !value.includes("/")) {
+        return null;
+    }
+    const [numeratorText, denominatorText] = value.split("/");
+    const numerator = Number.parseFloat(numeratorText || "");
+    const denominator = Number.parseFloat(denominatorText || "");
+    if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0) {
+        return null;
+    }
+    return Number((numerator / denominator).toFixed(4));
+}
+function toKbps(value) {
+    return value == null ? null : Math.round(value / 1000);
+}
+function formatSeconds(value) {
+    return value.toFixed(3);
+}
+function extensionForMediaUrl(mediaUrl, mediaType) {
+    try {
+        const extension = path.extname(new URL(mediaUrl).pathname).toLowerCase();
+        if (/^\.[a-z0-9]{2,5}$/i.test(extension)) {
+            return extension;
+        }
+    }
+    catch {
+        // Fall through to defaults.
+    }
+    return mediaType === "video" ? ".mp4" : ".img";
+}
+function normalizeFfmpegColor(value) {
+    const trimmed = value.trim();
+    const hex = /^#?([0-9a-f]{6})$/i.exec(trimmed);
+    if (hex) {
+        return `0x${hex[1]}`;
+    }
+    return /^[a-z]+$/i.test(trimmed) ? trimmed : "black";
+}
+function inferContentTypeFromPath(filePath, metadata) {
+    if (metadata.hasVideo) {
+        if (filePath.endsWith(".webm"))
+            return "video/webm";
+        if (filePath.endsWith(".mov"))
+            return "video/quicktime";
+        return "video/mp4";
+    }
+    if (metadata.hasAudio) {
+        if (filePath.endsWith(".wav"))
+            return "audio/wav";
+        if (filePath.endsWith(".m4a"))
+            return "audio/mp4";
+        if (filePath.endsWith(".ogg"))
+            return "audio/ogg";
+        return "audio/mpeg";
+    }
+    return null;
+}
+function formatUrlForError(url) {
+    return url.length > 300 ? `${url.slice(0, 300)}...` : url;
+}
+//# sourceMappingURL=media-processing.js.map