@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

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

@@ -1,766 +0,0 @@
-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