@officexapp/vidfarm-devcli 0.21.10

package/dist/src/services/captions.js

@@ -0,0 +1,123 @@
+// Turns a transcript into animated-caption cues. Shared by the devcli
+// `captions` command group, the /editor chat agent's set_captions action, and
+// any server surface that wants captions from STT output. Pure — no network,
+// no filesystem — so it is safe to import from the devcli.
+//
+// A "cue" is one caption layer on the timeline: a short run of words shown
+// together (CapCut-style pages of ~3-5 words), with per-word windows relative
+// to the cue start driving the animation. Word timings come from the provider
+// when available (openai whisper-1) and are char-weight estimated inside each
+// segment otherwise (gemini estimates, hand-typed text) — see
+// estimateCaptionWords.
+import { estimateCaptionWords } from "../hyperframes/composition.js";
+const CUE_TAIL_SEC = 0.12;
+const MIN_WORD_SPAN_SEC = 0.05;
+/** Flattens transcript segments into absolute-timed words, estimating windows
+ * for segments the provider left word-less (or entirely time-less — those
+ * distribute across fallbackDurationSec). */
+export function transcriptWordTimeline(segments, fallbackDurationSec) {
+    const words = [];
+    const timeless = segments.filter((segment) => typeof segment.start_sec !== "number");
+    for (const segment of segments) {
+        if (segment.words?.length) {
+            words.push(...segment.words.map((word) => ({ ...word, text: word.text.trim() })).filter((word) => word.text));
+            continue;
+        }
+        let base;
+        let span;
+        if (typeof segment.start_sec === "number") {
+            base = segment.start_sec;
+            span = typeof segment.end_sec === "number" && segment.end_sec > segment.start_sec
+                ? segment.end_sec - segment.start_sec
+                : 0;
+        }
+        else {
+            // No timings at all (plain-text providers): spread the blob across the
+            // caller-provided window so captions still land somewhere sensible.
+            base = 0;
+            span = Number.isFinite(fallbackDurationSec) && fallbackDurationSec > 0 && timeless.length
+                ? fallbackDurationSec / timeless.length
+                : 0;
+            if (timeless.length > 1) {
+                base = (span || 0) * timeless.indexOf(segment);
+            }
+        }
+        const estimated = estimateCaptionWords(segment.text, span);
+        words.push(...estimated.map((word) => ({
+            text: word.text,
+            start_sec: base + word.start,
+            end_sec: base + word.end
+        })));
+    }
+    return words
+        .filter((word) => Number.isFinite(word.start_sec) && Number.isFinite(word.end_sec) && word.end_sec > word.start_sec)
+        .sort((a, b) => a.start_sec - b.start_sec);
+}
+export function buildCaptionCues(segments, options) {
+    const words = transcriptWordTimeline(segments, options?.fallbackDurationSec);
+    return cuesFromWordTimeline(words, options);
+}
+export function cuesFromWordTimeline(words, options) {
+    const maxWords = Math.max(1, Math.round(options?.maxWordsPerCue ?? 4));
+    const maxDuration = Math.max(0.4, options?.maxCueDurationSec ?? 2.6);
+    const gapBreak = Math.max(0.15, options?.gapBreakSec ?? 0.6);
+    const offset = Number.isFinite(options?.offsetSec) ? options?.offsetSec : 0;
+    const cues = [];
+    let bucket = [];
+    const flush = () => {
+        if (!bucket.length)
+            return;
+        const start = bucket[0].start_sec;
+        const end = bucket[bucket.length - 1].end_sec + CUE_TAIL_SEC;
+        cues.push({
+            text: bucket.map((word) => word.text).join(" "),
+            start: round3(start + offset),
+            duration: round3(Math.max(MIN_WORD_SPAN_SEC * bucket.length, end - start)),
+            words: bucket.map((word) => ({
+                text: word.text,
+                start: round3(Math.max(0, word.start_sec - start)),
+                end: round3(Math.max(word.start_sec - start + MIN_WORD_SPAN_SEC, word.end_sec - start))
+            }))
+        });
+        bucket = [];
+    };
+    for (const word of words) {
+        if (bucket.length) {
+            const cueStart = bucket[0].start_sec;
+            const previous = bucket[bucket.length - 1];
+            const silence = word.start_sec - previous.end_sec;
+            const wouldRun = word.end_sec - cueStart;
+            const sentenceBreak = /[.!?…]["')\]]?$/.test(previous.text);
+            if (bucket.length >= maxWords || silence > gapBreak || wouldRun > maxDuration || sentenceBreak) {
+                flush();
+            }
+        }
+        bucket.push(word);
+    }
+    flush();
+    // Clamp each cue against the next so consecutive caption layers never
+    // overlap on the shared track (one-clip-per-(track,time) invariant).
+    for (let index = 0; index < cues.length - 1; index += 1) {
+        const cue = cues[index];
+        const next = cues[index + 1];
+        const maxEnd = next.start - 0.02;
+        if (cue.start + cue.duration > maxEnd) {
+            cue.duration = round3(Math.max(MIN_WORD_SPAN_SEC, maxEnd - cue.start));
+        }
+    }
+    return cues.filter((cue) => cue.duration > 0);
+}
+/** Cues straight from plain text spread across a window — the no-transcript
+ * path (AI-authored captions, manual cue text). */
+export function cuesFromText(text, startSec, durationSec, options) {
+    const words = estimateCaptionWords(text, durationSec).map((word) => ({
+        text: word.text,
+        start_sec: startSec + word.start,
+        end_sec: startSec + word.end
+    }));
+    return cuesFromWordTimeline(words, options);
+}
+function round3(value) {
+    return Number(value.toFixed(3));
+}
+//# sourceMappingURL=captions.js.map

package/dist/src/services/clip-curation/cost.js

@@ -0,0 +1,116 @@
+// Cost estimation for a scan — surfaced BEFORE every scan (success criterion #6)
+// and used by the devcli --dry-run gate. Provider/model-aware: prices the
+// resolved tagging model (gemini / openai gpt-5.4-nano / openrouter gemini) plus
+// the embedding model. BYOK: this is the LLM spend the user pays directly.
+function envPrice(envKey, fallback) {
+    const v = Number(process.env[envKey]);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+// Approximate list prices, USD per 1M tokens (overridable via env). Estimates —
+// the real bill comes from the user's provider account.
+const MODEL_PRICING = {
+    "gemini-2.5-flash-lite": { input: envPrice("VIDFARM_PRICE_FLASH_LITE_INPUT", 0.1), output: envPrice("VIDFARM_PRICE_FLASH_LITE_OUTPUT", 0.4) },
+    "gemini-2.5-flash": { input: envPrice("VIDFARM_PRICE_FLASH_INPUT", 0.3), output: envPrice("VIDFARM_PRICE_FLASH_OUTPUT", 2.5) },
+    // OpenRouter adds a small markup over Google's list price.
+    "google/gemini-2.5-flash": { input: envPrice("VIDFARM_PRICE_OR_FLASH_INPUT", 0.315), output: envPrice("VIDFARM_PRICE_OR_FLASH_OUTPUT", 2.625) },
+    "gpt-5.4-nano": { input: envPrice("VIDFARM_PRICE_GPT5_NANO_INPUT", 0.05), output: envPrice("VIDFARM_PRICE_GPT5_NANO_OUTPUT", 0.4) },
+    // Nvidia lite clipping model (minimaxai/minimax-m3) — approximate, env-overridable.
+    "minimaxai/minimax-m3": { input: envPrice("VIDFARM_PRICE_NVIDIA_MINIMAX_INPUT", 0.15), output: envPrice("VIDFARM_PRICE_NVIDIA_MINIMAX_OUTPUT", 0.6) }
+};
+const DEFAULT_TAG_PRICING = { input: 0.15, output: 0.6 };
+const EMBED_PRICING = {
+    "gemini-embedding-001": envPrice("VIDFARM_PRICE_EMBEDDING_INPUT", 0.15),
+    "text-embedding-3-small": envPrice("VIDFARM_PRICE_OPENAI_EMBEDDING_INPUT", 0.02)
+};
+// Low-res image tokens: Gemini media_resolution LOW = 66/frame; OpenAI
+// low-detail ≈ 85/frame. Audio ~32 tok/sec (Gemini only — OpenAI/OpenRouter
+// chat models don't take the raw audio clip, so those skip it).
+function imageTokensPerFrame(provider) {
+    return provider === "openai" ? 85 : 66;
+}
+const PROMPT_OVERHEAD_TOKENS = 280;
+const AUDIO_TOKENS_PER_SEC = 32;
+// OpenAI's nano reasoning model emits more output tokens than Gemini's terse JSON.
+function outputTokensPerScene(provider) {
+    return provider === "openai" ? 350 : 150;
+}
+const EMBEDDING_TOKENS_PER_SCENE = 60;
+const DEFAULT_AVG_SCENE_SEC = 4;
+export function estimateScanCostFromScenes(scenes, opts) {
+    const durationSec = scenes.reduce((acc, s) => acc + s.duration_sec, 0);
+    const avgSceneSec = scenes.length ? durationSec / scenes.length : DEFAULT_AVG_SCENE_SEC;
+    return compute({ ...normalize(opts), durationSec, scenes: scenes.length, avgSceneSec });
+}
+export function estimateScanCostFromDuration(durationSec, opts) {
+    const avgSceneSec = opts.avgSceneSec ?? DEFAULT_AVG_SCENE_SEC;
+    const scenes = Math.max(1, Math.ceil(durationSec / avgSceneSec));
+    return compute({ ...normalize(opts), durationSec, scenes, avgSceneSec });
+}
+function normalize(opts) {
+    const provider = opts.provider ?? "gemini";
+    const tagModelId = opts.tagModelId ?? defaultTagModel(provider, opts.tier);
+    return {
+        tier: opts.tier,
+        provider,
+        tagModelId,
+        embedModelId: opts.embedModelId ?? null,
+        framesPerScene: opts.framesPerScene ?? 2,
+        includeAudio: opts.includeAudio ?? true
+    };
+}
+function defaultTagModel(provider, tier) {
+    if (provider === "openai")
+        return "gpt-5.4-nano";
+    if (provider === "openrouter")
+        return "google/gemini-2.5-flash";
+    if (provider === "nvidia")
+        return "minimaxai/minimax-m3";
+    return tier === "flash" ? "gemini-2.5-flash" : "gemini-2.5-flash-lite";
+}
+function compute(input) {
+    const { provider, tagModelId, embedModelId, framesPerScene, includeAudio, durationSec, scenes, avgSceneSec } = input;
+    // Audio is only sent to Gemini (native audio input).
+    const audioTokensPerScene = includeAudio && provider === "gemini" ? Math.round(avgSceneSec * AUDIO_TOKENS_PER_SEC) : 0;
+    const taggingInputPerScene = framesPerScene * imageTokensPerFrame(provider) + PROMPT_OVERHEAD_TOKENS + audioTokensPerScene;
+    const taggingInputTokens = taggingInputPerScene * scenes;
+    const taggingOutputTokens = outputTokensPerScene(provider) * scenes;
+    const embeddingTokens = embedModelId ? EMBEDDING_TOKENS_PER_SCENE * scenes : 0;
+    const tagPrice = MODEL_PRICING[tagModelId] ?? DEFAULT_TAG_PRICING;
+    const embedPrice = embedModelId ? EMBED_PRICING[embedModelId] ?? 0.15 : 0;
+    const usd = (taggingInputTokens / 1_000_000) * tagPrice.input +
+        (taggingOutputTokens / 1_000_000) * tagPrice.output +
+        (embeddingTokens / 1_000_000) * embedPrice;
+    const hours = durationSec / 3600;
+    const usdPerHour = hours > 0 ? usd / hours : usd;
+    return {
+        tier: input.tier,
+        provider,
+        tag_model: tagModelId,
+        embed_model: embedModelId,
+        duration_sec: round2(durationSec),
+        estimated_scenes: scenes,
+        frames_per_scene: framesPerScene,
+        tagging_input_tokens: taggingInputTokens,
+        tagging_output_tokens: taggingOutputTokens,
+        embedding_tokens: embeddingTokens,
+        usd: round4(usd),
+        usd_per_source_hour: round4(usdPerHour)
+    };
+}
+/** Human-readable one-liner for the CLI / API. */
+export function formatCostEstimate(est) {
+    const mins = (est.duration_sec / 60).toFixed(1);
+    return [
+        `~$${est.usd.toFixed(3)} for ${mins} min`,
+        `(${est.estimated_scenes} scenes · ${est.tag_model}${est.embed_model ? ` + ${est.embed_model}` : " · no embeddings"})`,
+        `≈ $${est.usd_per_source_hour.toFixed(3)}/source-hour`,
+        `| tokens: ${est.tagging_input_tokens.toLocaleString()} in + ${est.tagging_output_tokens.toLocaleString()} out + ${est.embedding_tokens.toLocaleString()} embed`
+    ].join(" ");
+}
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}
+function round4(n) {
+    return Math.round(n * 10000) / 10000;
+}
+//# sourceMappingURL=cost.js.map

package/dist/src/services/clip-curation/ffmpeg.js

@@ -0,0 +1,352 @@
+// ffmpeg/ffprobe helpers for clip curation — scene detection, keyframe/clip/
+// thumbnail extraction, per-scene audio for ASR. Same flags on devcli (local
+// ffmpeg-static) and cloud (bundled ffmpeg-static in the scan Lambda), so both
+// targets cut identical clips. Resolution order matches the rest of the repo:
+// HYPERFRAMES_FFMPEG_PATH/FFPROBE env → ffmpeg-static/ffprobe-static → PATH.
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+let cachedFfmpeg;
+let cachedFfprobe;
+export async function resolveFfmpeg() {
+    if (cachedFfmpeg !== undefined)
+        return cachedFfmpeg ?? "ffmpeg";
+    const envPath = process.env.HYPERFRAMES_FFMPEG_PATH?.trim();
+    if (envPath && existsSync(envPath))
+        return (cachedFfmpeg = envPath);
+    try {
+        const mod = (await import("ffmpeg-static"));
+        const resolved = typeof mod === "string" ? mod : mod.default;
+        if (typeof resolved === "string" && resolved && existsSync(resolved))
+            return (cachedFfmpeg = resolved);
+    }
+    catch {
+        /* fall through to PATH */
+    }
+    cachedFfmpeg = null;
+    return "ffmpeg";
+}
+export async function resolveFfprobe() {
+    if (cachedFfprobe !== undefined)
+        return cachedFfprobe ?? "ffprobe";
+    const envPath = process.env.HYPERFRAMES_FFPROBE_PATH?.trim() ?? process.env.FFPROBE_PATH?.trim();
+    if (envPath && existsSync(envPath))
+        return (cachedFfprobe = envPath);
+    try {
+        const mod = (await import("ffprobe-static"));
+        const p = (mod.path ?? mod.default?.path);
+        if (typeof p === "string" && p && existsSync(p))
+            return (cachedFfprobe = p);
+    }
+    catch {
+        /* fall through to PATH */
+    }
+    cachedFfprobe = null;
+    return "ffprobe";
+}
+/** True if a usable ffmpeg is available (bundled or on PATH). */
+export async function hasFfmpeg() {
+    const bin = await resolveFfmpeg();
+    const { code } = await run(bin, ["-version"]).catch(() => ({ code: 1, stdout: "", stderr: "" }));
+    return code === 0;
+}
+function run(bin, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => (stdout += d.toString()));
+        child.stderr.on("data", (d) => (stderr += d.toString()));
+        child.on("error", reject);
+        child.on("close", (code) => resolve({ code: code ?? 0, stdout, stderr }));
+    });
+}
+/** Probe a source video for duration/dimensions/codec/size/fps. */
+export async function probeVideo(videoPath) {
+    const ffprobe = await resolveFfprobe();
+    const { stdout } = await run(ffprobe, [
+        "-v", "error",
+        "-print_format", "json",
+        "-show_format",
+        "-show_streams",
+        videoPath
+    ]);
+    let parsed = {};
+    try {
+        parsed = JSON.parse(stdout || "{}");
+    }
+    catch {
+        parsed = {};
+    }
+    const streams = Array.isArray(parsed.streams) ? parsed.streams : [];
+    const video = streams.find((s) => s.codec_type === "video");
+    const format = parsed.format ?? {};
+    const duration = Number(format.duration ?? video?.duration ?? 0) || 0;
+    let fps = null;
+    if (video?.avg_frame_rate && typeof video.avg_frame_rate === "string") {
+        const [num, den] = video.avg_frame_rate.split("/").map(Number);
+        if (num && den)
+            fps = num / den;
+    }
+    return {
+        duration_sec: duration,
+        width: video?.width ?? null,
+        height: video?.height ?? null,
+        codec: video?.codec_name ?? null,
+        size_bytes: format.size ? Number(format.size) : null,
+        fps
+    };
+}
+/**
+ * Detect scene boundaries with the portable `select='gt(scene,T)',showinfo`
+ * pass, parsing pts_time from ffmpeg's stderr. Falls back to fixed-interval
+ * chunking when nothing is detected (e.g. a single continuous take), so a scan
+ * always yields clips. Same command shape on devcli and cloud. With
+ * opts.windows set, each window is detected independently and scene times are
+ * offset back into source time.
+ */
+export async function detectScenes(videoPath, opts = {}) {
+    const duration = opts.durationSec ?? (await probeVideo(videoPath)).duration_sec;
+    if (!Number.isFinite(duration) || duration <= 0)
+        return [];
+    const windows = (opts.windows ?? [])
+        .map((w) => ({ start_sec: Math.max(0, w.start_sec), end_sec: Math.min(w.end_sec, duration) }))
+        .filter((w) => w.end_sec - w.start_sec > 0.25);
+    if (windows.length === 0) {
+        return detectScenesInSpan(videoPath, { ...opts, durationSec: duration, spanStart: 0, spanEnd: duration, indexOffset: 0 });
+    }
+    const scenes = [];
+    for (const window of windows) {
+        const detected = await detectScenesInSpan(videoPath, {
+            ...opts,
+            durationSec: duration,
+            spanStart: window.start_sec,
+            spanEnd: window.end_sec,
+            indexOffset: scenes.length
+        });
+        scenes.push(...detected);
+    }
+    return scenes;
+}
+async function detectScenesInSpan(videoPath, opts) {
+    const threshold = opts.threshold ?? 0.3;
+    // Preserve very short detected shots as independent candidates. Absorbing a
+    // 2-10 frame flash into its neighbour makes it impossible for prompt/OCR
+    // refinement to reject that flash later. 50ms only de-duplicates effectively
+    // identical detector timestamps.
+    const minScene = opts.minSceneSec ?? 0.05;
+    const maxScene = opts.maxSceneSec ?? 8;
+    const { spanStart, spanEnd } = opts;
+    const spanDuration = spanEnd - spanStart;
+    if (!Number.isFinite(spanDuration) || spanDuration <= 0)
+        return [];
+    const ffmpeg = await resolveFfmpeg();
+    // -ss/-t BEFORE -i: input-seek so only the window is decoded. pts_time then
+    // restarts near 0, so cuts are offset back by spanStart below.
+    const seekArgs = spanStart > 0 || spanEnd < (opts.durationSec ?? Infinity)
+        ? ["-ss", spanStart.toFixed(3), "-t", spanDuration.toFixed(3)]
+        : [];
+    const { stderr } = await run(ffmpeg, [
+        "-hide_banner",
+        ...seekArgs,
+        "-i", videoPath,
+        "-filter:v", `select='gt(scene,${threshold})',showinfo`,
+        "-f", "null",
+        "-"
+    ]);
+    const cuts = [];
+    const re = /pts_time:([0-9.]+)/g;
+    let m;
+    while ((m = re.exec(stderr)) !== null) {
+        const t = Number(m[1]) + (seekArgs.length ? spanStart : 0);
+        if (Number.isFinite(t) && t > spanStart && t < spanEnd)
+            cuts.push(t);
+    }
+    cuts.sort((a, b) => a - b);
+    // Build [spanStart, cut1, cut2, …, spanEnd] boundaries.
+    let bounds = [spanStart, ...cuts, spanEnd];
+    // If nothing detected, chunk at maxScene.
+    if (cuts.length === 0) {
+        bounds = [spanStart];
+        for (let t = spanStart + maxScene; t < spanEnd; t += maxScene)
+            bounds.push(t);
+        bounds.push(spanEnd);
+    }
+    // Merge boundaries closer than minScene.
+    const merged = [bounds[0]];
+    for (let i = 1; i < bounds.length; i++) {
+        if (bounds[i] - merged[merged.length - 1] >= minScene || i === bounds.length - 1) {
+            merged.push(bounds[i]);
+        }
+    }
+    const scenes = [];
+    for (let i = 0; i < merged.length - 1; i++) {
+        let start = merged[i];
+        const end = merged[i + 1];
+        // Split over-long scenes so clips stay usable and tagging stays cheap.
+        const span = end - start;
+        if (span > maxScene) {
+            const chunks = Math.ceil(span / maxScene);
+            const step = span / chunks;
+            for (let c = 0; c < chunks; c++) {
+                const s = start + c * step;
+                const e = c === chunks - 1 ? end : s + step;
+                scenes.push(makeScene(opts.indexOffset + scenes.length, s, e));
+            }
+        }
+        else {
+            scenes.push(makeScene(opts.indexOffset + scenes.length, start, end));
+        }
+    }
+    return scenes;
+}
+function makeScene(index, start, end) {
+    const s = Math.max(0, start);
+    const e = Math.max(s + 0.01, end);
+    return { index, start_time_sec: round3(s), end_time_sec: round3(e), duration_sec: round3(e - s) };
+}
+/** Extract up to `count` small keyframe JPEGs across a scene (for low-cost tagging). */
+export async function extractKeyframes(input) {
+    const count = Math.max(1, Math.min(3, input.count ?? 2));
+    const width = input.width ?? 384;
+    mkdirSync(input.outDir, { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    // Sample points inside the clip, avoiding the very edges.
+    const points = count === 1
+        ? [start + dur / 2]
+        : Array.from({ length: count }, (_, i) => start + dur * ((i + 1) / (count + 1)));
+    const vf = input.cropFilter ? `${input.cropFilter},scale=${width}:-2` : `scale=${width}:-2`;
+    const outPaths = [];
+    for (let i = 0; i < points.length; i++) {
+        const out = path.join(input.outDir, `scene-${input.scene.index}-kf${i}.jpg`);
+        const { code } = await run(ffmpeg, [
+            "-y",
+            "-ss", points[i].toFixed(3),
+            "-i", input.videoPath,
+            "-frames:v", "1",
+            "-vf", vf,
+            "-q:v", "5",
+            out
+        ]);
+        if (code === 0 && existsSync(out))
+            outPaths.push(out);
+    }
+    return outPaths;
+}
+/** Cut the scene into a standalone mp4 (re-encoded for frame-accurate boundaries). */
+export async function extractClip(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    // A crop cannot ride on stream-copy — force the re-encode path when present.
+    const args = input.reencode === false && !input.cropFilter
+        ? ["-y", "-ss", start.toFixed(3), "-i", input.videoPath, "-t", dur.toFixed(3), "-c", "copy", "-avoid_negative_ts", "make_zero", input.outPath]
+        : [
+            "-y",
+            "-ss", start.toFixed(3),
+            "-i", input.videoPath,
+            "-t", dur.toFixed(3),
+            ...(input.cropFilter ? ["-vf", input.cropFilter] : []),
+            "-c:v", "libx264", "-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p",
+            "-c:a", "aac", "-b:a", "128k",
+            "-movflags", "+faststart",
+            input.outPath
+        ];
+    const { code, stderr } = await run(ffmpeg, args);
+    const ok = code === 0 && existsSync(input.outPath);
+    if (!ok) {
+        input.onError?.(`ffmpeg exit ${code}: ${stderr.slice(-500).replace(/\s+/g, " ").trim()}`);
+    }
+    return ok;
+}
+/**
+ * Trim EXACTLY [start, start+dur] of the source's AUDIO into a standalone
+ * `.m4a` (AAC) file — the audio-only twin of {@link extractClip}. The video
+ * track is dropped (`-vn`) so the result is a small, editor-placeable audio raw
+ * (e.g. clipping the soundtrack out of a copyright-free YouTube video). Returns
+ * false if the source has no audio track (ffmpeg exits non-zero with no output).
+ */
+export async function extractAudioClip(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    const { code, stderr } = await run(ffmpeg, [
+        "-y",
+        "-ss", start.toFixed(3),
+        "-i", input.videoPath,
+        "-t", dur.toFixed(3),
+        "-vn",
+        "-c:a", "aac", "-b:a", "192k",
+        "-movflags", "+faststart",
+        input.outPath
+    ]);
+    const ok = code === 0 && existsSync(input.outPath);
+    if (!ok)
+        input.onError?.(`ffmpeg exit ${code}: ${stderr.slice(-500).replace(/\s+/g, " ").trim()}`);
+    return ok;
+}
+/**
+ * A static waveform PNG for an audio clip — its "thumbnail" so an audio-only raw
+ * still shows something in the raws gallery (there is no video frame to grab).
+ * Best-effort; returns false if the source has no audio to plot.
+ */
+export async function extractWaveformThumbnail(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    const w = input.width ?? 320;
+    const h = input.height ?? 200;
+    const { code } = await run(ffmpeg, [
+        "-y",
+        "-ss", start.toFixed(3),
+        "-i", input.videoPath,
+        "-t", dur.toFixed(3),
+        "-filter_complex", `showwavespic=s=${w}x${h}:colors=#e2a63a`,
+        "-frames:v", "1",
+        input.outPath
+    ]);
+    return code === 0 && existsSync(input.outPath);
+}
+/** Single representative thumbnail for the scene. */
+export async function extractThumbnail(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const mid = input.scene.start_time_sec + input.scene.duration_sec / 2;
+    const vf = input.cropFilter
+        ? `${input.cropFilter},scale=${input.width ?? 320}:-2`
+        : `scale=${input.width ?? 320}:-2`;
+    const { code } = await run(ffmpeg, [
+        "-y",
+        "-ss", mid.toFixed(3),
+        "-i", input.videoPath,
+        "-frames:v", "1",
+        "-vf", vf,
+        "-q:v", "3",
+        input.outPath
+    ]);
+    return code === 0 && existsSync(input.outPath);
+}
+/** Extract a small mono/16k audio clip for the scene (feeds Gemini ASR). Returns null if no audio track. */
+export async function extractSceneAudio(input) {
+    mkdirSync(path.dirname(input.outPath), { recursive: true });
+    const ffmpeg = await resolveFfmpeg();
+    const { start_time_sec: start, duration_sec: dur } = input.scene;
+    const { code } = await run(ffmpeg, [
+        "-y",
+        "-ss", start.toFixed(3),
+        "-i", input.videoPath,
+        "-t", dur.toFixed(3),
+        "-vn",
+        "-ac", "1",
+        "-ar", "16000",
+        "-c:a", "libmp3lame",
+        "-b:a", "32k",
+        input.outPath
+    ]);
+    return code === 0 && existsSync(input.outPath) ? input.outPath : null;
+}
+function round3(n) {
+    return Math.round(n * 1000) / 1000;
+}
+//# sourceMappingURL=ffmpeg.js.map