@officexapp/vidfarm-devcli 0.21.10

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

@@ -0,0 +1,470 @@
+// Clip-hunt spec — the user-facing controls for turning long-form video into
+// short-form clips: time WINDOWS ("only hunt between 12:30 and 15:45"), a soft
+// target DURATION band ("30 sec clips" → 20–40s), an output ASPECT crop
+// ("vertical video of people holding food to their face"), and an avoid-text
+// constraint ("without captions / no on-screen text" — a scene-SELECTION filter,
+// NEVER GhostCut on the long-form source). Shared by devcli (local), the Hono
+// API, and the cloud scan Lambda so every surface parses and normalizes
+// identically. All helpers are pure/deterministic — no AI calls here.
+import { ACTIVE_TAXONOMY_VERSION, getTaxonomy } from "./taxonomy.js";
+// ── Unspecified-prompt defaults ─────────────────────────────────────────────
+// When a user imports a source video without saying what they want, we bias
+// toward the short-form product default: a handful of DISTINCT, vertical,
+// text-free 5–15s clips rather than every raw cut. These fill only the gaps —
+// any field the user (or their prompt) sets always wins.
+/** Default soft clip length when unspecified: ~10s, 5–15s band. */
+export const DEFAULT_CLIP_DURATION_BAND = { min_sec: 5, max_sec: 15, target_sec: 10 };
+/** Default mining density when neither max_clips nor clips_per_10min is set. */
+export const DEFAULT_CLIPS_PER_10_MIN = 10;
+/** Default output aspect when unspecified (vertical / shorts). */
+export const DEFAULT_CLIP_ASPECT = "9:16";
+/**
+ * Fill the unspecified-prompt defaults on a normalized hunt spec: a 5–15s
+ * duration band, vertical 9:16 crop, and avoid-text ON. Only fills gaps — an
+ * explicit user choice (including avoid_text:false) is preserved.
+ */
+export function applyHuntSpecDefaults(spec) {
+    const out = { ...spec };
+    if (!out.duration_band)
+        out.duration_band = { ...DEFAULT_CLIP_DURATION_BAND };
+    if (out.avoid_text === undefined)
+        out.avoid_text = true;
+    if (!out.aspect)
+        out.aspect = DEFAULT_CLIP_ASPECT;
+    return out;
+}
+/**
+ * The number of clips to aim for given the (effective, windowed) source
+ * duration. A hard max_clips wins; otherwise density (default 10 per 10 min ≈
+ * one clip per minute) scales with length. Always ≥ 1.
+ */
+export function resolveTargetClipCount(effectiveDurationSec, spec) {
+    if (spec.max_clips && spec.max_clips > 0)
+        return Math.max(1, Math.round(spec.max_clips));
+    const per10 = spec.clips_per_10min && spec.clips_per_10min > 0 ? spec.clips_per_10min : DEFAULT_CLIPS_PER_10_MIN;
+    const tenMinBlocks = Math.max(0, effectiveDurationSec) / 600;
+    return Math.max(1, Math.round(tenMinBlocks * per10));
+}
+/**
+ * Deterministic count cap / uniqueness backstop: when more scenes survived than
+ * the target, keep an EVENLY-SPACED subset across the timeline. Spread-out
+ * scenes are far less likely to be near-duplicates of each other than adjacent
+ * ones, so this doubles as a cheap "distinct clips" filter when the AI refine
+ * pass is skipped (>60 scenes) or over-returns. Re-indexes the survivors.
+ */
+export function capScenesEvenlyToCount(scenes, target) {
+    if (!Number.isFinite(target) || target <= 0 || scenes.length <= target)
+        return scenes;
+    const step = scenes.length / target;
+    const picked = [];
+    const seen = new Set();
+    for (let i = 0; i < target; i++) {
+        const idx = Math.min(scenes.length - 1, Math.floor(i * step + step / 2));
+        if (seen.has(idx))
+            continue;
+        seen.add(idx);
+        picked.push(scenes[idx]);
+    }
+    return picked.map((s, i) => ({ ...s, index: i }));
+}
+// ── Duration band ───────────────────────────────────────────────────────────
+/**
+ * Map a spoken target ("10 sec", "30 sec", "60 sec", "120 sec") to a soft
+ * range. Anchors from product: 10 → 5–20, 30 → 20–40; the same formula extends
+ * smoothly (60 → 40–80, 120 → 80–160): ± target/3, with a minimum slack of
+ * −5s / +10s so short targets keep a usable band.
+ */
+export function resolveDurationBand(targetSec) {
+    if (!Number.isFinite(targetSec) || targetSec <= 0)
+        return null;
+    const target = Math.max(3, Math.min(600, targetSec));
+    const minSec = Math.max(2, round1(target - Math.max(target / 3, 5)));
+    const maxSec = round1(target + Math.max(target / 3, 10));
+    return { min_sec: minSec, max_sec: maxSec, target_sec: round1(target) };
+}
+// ── Timecodes & windows ─────────────────────────────────────────────────────
+/** "1:02:03(.5)" | "12:30" | "95" | "95.5" → seconds (null when unparseable). */
+export function parseTimecode(text) {
+    const trimmed = (text ?? "").trim();
+    if (!trimmed)
+        return null;
+    const parts = trimmed.split(":");
+    if (parts.length > 3)
+        return null;
+    let seconds = 0;
+    for (const part of parts) {
+        if (!/^\d+(\.\d+)?$/.test(part))
+            return null;
+        seconds = seconds * 60 + Number(part);
+    }
+    return Number.isFinite(seconds) ? seconds : null;
+}
+/**
+ * Parse "12:30-15:45, 20:00-22:10" (also "–" and "to" separators, or
+ * {start,end} objects / [start,end] tuples) into windows. Invalid entries are
+ * dropped rather than failing the scan.
+ */
+export function parseTimeRanges(input) {
+    const out = [];
+    const push = (start, end) => {
+        if (start == null || end == null)
+            return;
+        if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start)
+            return;
+        out.push({ start_sec: round3(Math.max(0, start)), end_sec: round3(end) });
+    };
+    const parseOne = (value) => {
+        if (typeof value === "string") {
+            const m = value.trim().match(/^(.+?)\s*(?:-|–|—|\bto\b)\s*(.+)$/i);
+            if (m)
+                push(parseTimecode(m[1]), parseTimecode(m[2]));
+            return;
+        }
+        if (Array.isArray(value) && value.length === 2) {
+            push(toSeconds(value[0]), toSeconds(value[1]));
+            return;
+        }
+        if (value && typeof value === "object") {
+            const rec = value;
+            push(toSeconds(rec.start_sec ?? rec.start ?? rec.from), toSeconds(rec.end_sec ?? rec.end ?? rec.to));
+        }
+    };
+    if (typeof input === "string") {
+        for (const piece of input.split(/[,;]+/))
+            parseOne(piece);
+    }
+    else if (Array.isArray(input)) {
+        for (const piece of input)
+            parseOne(piece);
+    }
+    else if (input != null) {
+        parseOne(input);
+    }
+    return out;
+}
+function toSeconds(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "string")
+        return parseTimecode(value);
+    return null;
+}
+/** Clamp to [0, durationSec], drop empties, sort, and merge overlaps. */
+export function normalizeWindows(windows, durationSec) {
+    if (!windows?.length)
+        return [];
+    const clamped = windows
+        .map((w) => ({
+        start_sec: Math.max(0, w.start_sec),
+        end_sec: durationSec && durationSec > 0 ? Math.min(w.end_sec, durationSec) : w.end_sec
+    }))
+        .filter((w) => Number.isFinite(w.start_sec) && Number.isFinite(w.end_sec) && w.end_sec - w.start_sec > 0.25)
+        .sort((a, b) => a.start_sec - b.start_sec);
+    const merged = [];
+    for (const w of clamped) {
+        const prev = merged[merged.length - 1];
+        if (prev && w.start_sec <= prev.end_sec + 0.05) {
+            prev.end_sec = Math.max(prev.end_sec, w.end_sec);
+        }
+        else {
+            merged.push({ ...w });
+        }
+    }
+    return merged;
+}
+/** The duration the scan actually processes — the cost-estimate input. */
+export function effectiveHuntDurationSec(fullDurationSec, windows) {
+    const normalized = normalizeWindows(windows, fullDurationSec);
+    if (!normalized.length)
+        return fullDurationSec;
+    return round3(normalized.reduce((acc, w) => acc + (w.end_sec - w.start_sec), 0));
+}
+// ── Aspect / crop ───────────────────────────────────────────────────────────
+const ASPECT_SYNONYMS = {
+    "9:16": "9:16",
+    "16:9": "16:9",
+    "4:3": "4:3",
+    "1:1": "1:1",
+    vertical: "9:16",
+    portrait: "9:16",
+    shorts: "9:16",
+    reels: "9:16",
+    tiktok: "9:16",
+    horizontal: "16:9",
+    landscape: "16:9",
+    widescreen: "16:9",
+    square: "1:1",
+    original: "original"
+};
+export function normalizeAspect(value) {
+    if (typeof value !== "string")
+        return null;
+    return ASPECT_SYNONYMS[value.trim().toLowerCase()] ?? null;
+}
+export function normalizeCropFocus(value) {
+    return value === "top" || value === "bottom" || value === "left" || value === "right" ? value : "center";
+}
+/**
+ * ffmpeg -vf crop expression for the target aspect: full-height (or full-width)
+ * centre crop with a focus bias — "smart centre" framing; the content guidance
+ * drives WHICH scenes are kept, this drives how each frame is cropped. Even
+ * output dims keep libx264 happy. Null = no crop.
+ */
+export function cropFilterFor(aspect, focus = "center") {
+    if (!aspect || aspect === "original")
+        return null;
+    const [aw, ah] = aspect.split(":").map(Number);
+    if (!aw || !ah)
+        return null;
+    const ratio = (aw / ah).toFixed(6);
+    const xf = focus === "left" ? "0.15" : focus === "right" ? "0.85" : "0.5";
+    // "top" biases toward faces/upper third when cropping vertically.
+    const yf = focus === "top" ? "0.2" : focus === "bottom" ? "0.8" : "0.5";
+    const w = `2*floor(min(iw\\,ih*${ratio})/2)`;
+    const h = `2*floor(min(ih\\,iw/${ratio})/2)`;
+    return `crop=w=${w}:h=${h}:x=(iw-ow)*${xf}:y=(ih-oh)*${yf}`;
+}
+// ── Scene fitting ───────────────────────────────────────────────────────────
+/**
+ * Fit detected scenes to a soft duration band: greedily merge CONTIGUOUS
+ * scenes toward the target (never across dropped gaps — post-refine lists have
+ * holes and merging across them would re-include dropped footage), and split
+ * over-long spans into ≤ max chunks. Safe to run both before refine (fewer,
+ * clip-sized units to judge) and after (re-enforce max on refine merges).
+ */
+export function fitScenesToDurationBand(scenes, band) {
+    if (!band || scenes.length === 0)
+        return scenes;
+    const EPS = 0.05;
+    const spans = [];
+    let cur = null;
+    for (const s of scenes) {
+        if (!cur) {
+            cur = { start: s.start_time_sec, end: s.end_time_sec };
+            continue;
+        }
+        const contiguous = Math.abs(s.start_time_sec - cur.end) <= EPS;
+        const curDur = cur.end - cur.start;
+        const nextDur = s.end_time_sec - s.start_time_sec;
+        const wantMore = curDur < band.min_sec || (curDur < band.target_sec && curDur + nextDur <= band.max_sec);
+        if (contiguous && wantMore) {
+            cur.end = s.end_time_sec;
+            continue;
+        }
+        spans.push(cur);
+        cur = { start: s.start_time_sec, end: s.end_time_sec };
+    }
+    if (cur)
+        spans.push(cur);
+    const fitted = [];
+    for (const span of spans) {
+        const dur = span.end - span.start;
+        if (dur > band.max_sec) {
+            const chunks = Math.ceil(dur / band.max_sec);
+            const step = dur / chunks;
+            for (let i = 0; i < chunks; i++) {
+                const start = span.start + i * step;
+                const end = i === chunks - 1 ? span.end : start + step;
+                fitted.push(makeScene(fitted.length, start, end));
+            }
+        }
+        else {
+            fitted.push(makeScene(fitted.length, span.start, span.end));
+        }
+    }
+    // Orphan slivers (isolated scenes far below the band) are noise when the user
+    // asked for e.g. 30s clips — drop them unless they are all we have.
+    const solid = fitted.filter((s) => s.duration_sec >= band.min_sec / 2);
+    const kept = solid.length > 0 ? solid : fitted;
+    return kept.map((s, i) => ({ ...s, index: i }));
+}
+// ── Guidance composition ────────────────────────────────────────────────────
+export const AVOID_TEXT_GUIDANCE = "Only keep scenes with NO burned-in captions, subtitles, watermark text, or on-screen text overlays; drop any scene whose frame shows readable overlay text.";
+/**
+ * Compose the effective guidance prompt for the refine (keep/drop/merge) and
+ * tagging passes: the user's content intent plus the avoid-text constraint.
+ * avoid_text is deliberately a SELECTION filter — never caption removal
+ * (GhostCut) on the long-form source.
+ */
+export function buildEffectiveGuidance(input) {
+    const parts = [];
+    if (input.contentPrompt?.trim())
+        parts.push(input.contentPrompt.trim());
+    if (input.avoidText)
+        parts.push(AVOID_TEXT_GUIDANCE);
+    return parts.join("\n");
+}
+function canonicalizeContentTypeHint(value) {
+    const normalized = String(value ?? "")
+        .trim()
+        .toLowerCase()
+        .replace(/^#/, "")
+        .replace(/[\s-]+/g, "_");
+    if (!normalized)
+        return null;
+    if (normalized === "broll")
+        return "b_roll";
+    return normalized;
+}
+export function extractUserContentTypeHints(notes, version = ACTIVE_TAXONOMY_VERSION) {
+    const text = String(notes ?? "").trim();
+    if (!text)
+        return [];
+    const allowed = new Set(getTaxonomy(version).categories.content_type.map((value) => canonicalizeContentTypeHint(value)));
+    const found = new Set();
+    const capture = (value) => {
+        const normalized = canonicalizeContentTypeHint(value);
+        if (normalized && allowed.has(normalized))
+            found.add(normalized);
+    };
+    for (const match of text.matchAll(/\b(?:content[_\s-]*type|category|tag)s?\s*[:=]\s*([^\n.;]+)/gi)) {
+        const raw = String(match[1] ?? "");
+        for (const piece of raw.split(/[,/|]+|\band\b/gi))
+            capture(piece);
+    }
+    for (const match of text.matchAll(/\b#?(talking[\s_-]*head|b[\s_-]*roll|product[\s_-]*shot|screen[\s_-]*recording|demo|reaction|interview|establishing|lifestyle|text[\s_-]*graphic)\b/gi)) {
+        capture(String(match[1] ?? ""));
+    }
+    return [...found];
+}
+export function applyUserContentTypeHints(tags, notes, version = ACTIVE_TAXONOMY_VERSION) {
+    const hinted = extractUserContentTypeHints(notes, version);
+    if (!hinted.length)
+        return tags;
+    return {
+        ...tags,
+        content_type: [...new Set([...(tags.content_type ?? []), ...hinted])]
+    };
+}
+export function buildPrivateUserNotesGuidance(notes, version = ACTIVE_TAXONOMY_VERSION) {
+    const text = String(notes ?? "").trim();
+    if (!text)
+        return "";
+    const hinted = extractUserContentTypeHints(text, version);
+    const parts = [
+        `Private owner notes for this raw: "${text}". Use them to bias categorization and description, but stay truthful to the footage.`
+    ];
+    if (hinted.length) {
+        parts.push(`If the footage supports it, include these owner-requested private content_type tags: ${hinted.join(", ")}.`);
+    }
+    return parts.join("\n");
+}
+/**
+ * Deterministically extract structured hints from a free-form hunt prompt:
+ * "please only hunt for clips between 12:30 and 15:45", "short 10 sec clips",
+ * "vertical video … without captions". Structured request fields always take
+ * precedence; this only fills gaps. The prompt itself stays intact as content
+ * guidance.
+ */
+export function parseClipHuntPrompt(prompt) {
+    const text = (prompt ?? "").trim();
+    const result = { windows: [], target_duration_sec: null, aspect: null, avoid_text: false, max_clips: null };
+    if (!text)
+        return result;
+    const tc = "\\d{1,2}:\\d{2}(?::\\d{2})?(?:\\.\\d+)?";
+    // "between 12:30 and 15:45" / "from 12:30 to 15:45" / bare "12:30-15:45"
+    const rangeRe = new RegExp(`(?:between|from)?\\s*(${tc})\\s*(?:-|–|—|to|and|until)\\s*(${tc})`, "gi");
+    let m;
+    while ((m = rangeRe.exec(text)) !== null) {
+        const start = parseTimecode(m[1]);
+        const end = parseTimecode(m[2]);
+        if (start != null && end != null && end > start) {
+            result.windows.push({ start_sec: round3(start), end_sec: round3(end) });
+        }
+    }
+    const secMatch = /(\d{1,3}(?:\.\d+)?)\s*-?\s*(?:sec(?:ond)?s?)\b/i.exec(text);
+    const minMatch = /(\d{1,2}(?:\.\d+)?)\s*-?\s*(?:min(?:ute)?s?)\b(?!\s*(?:mark|point))/i.exec(text);
+    if (secMatch) {
+        result.target_duration_sec = Number(secMatch[1]);
+    }
+    else if (minMatch && /clip/i.test(text)) {
+        // "2 minute clips" — only treat minutes as a duration when clips are the topic.
+        result.target_duration_sec = Number(minMatch[1]) * 60;
+    }
+    const aspectToken = /(\d{1,2}:\d{1,2})\s*(?:video|clip|ratio|aspect|crop)/i.exec(text)?.[1];
+    result.aspect =
+        normalizeAspect(aspectToken) ??
+            (/(vertical|portrait)\b/i.test(text) ? "9:16"
+                : /(horizontal|landscape|widescreen)\b/i.test(text) ? "16:9"
+                    : /\bsquare\b/i.test(text) ? "1:1"
+                        : /\b4:3\b/.test(text) ? "4:3"
+                            : null);
+    result.avoid_text =
+        /(without|no)\s+(?:any\s+)?(captions?|subtitles?|(?:on[- ]?screen\s+)?text)/i.test(text) ||
+            /\b(caption|text)-free\b/i.test(text) ||
+            /no\s+text\s+on\s+screen/i.test(text);
+    // "10 clips" / "give me 20 raws" / "top 5 cuts" → a clip-count target.
+    const countMatch = /(\d{1,3})\s*(?:clips?|raws?|shots?|cuts?|segments?)\b/i.exec(text) ??
+        /\b(?:top|best|give me|find|get|pull|grab)\s+(\d{1,3})\b/i.exec(text);
+    if (countMatch) {
+        const n = Number(countMatch[1]);
+        if (Number.isFinite(n) && n > 0)
+            result.max_clips = Math.min(500, Math.round(n));
+    }
+    return result;
+}
+// ── Wire normalization (API / SFN / tool payloads) ──────────────────────────
+/**
+ * Normalize an untrusted hunt-spec-shaped payload (HTTP body, tool args, SFN
+ * input) into a clean ClipHuntSpec. Unknown/invalid fields drop out silently.
+ */
+export function normalizeHuntSpec(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    const rec = raw;
+    const spec = {};
+    const windows = parseTimeRanges(rec.windows ?? rec.ranges ?? rec.time_ranges);
+    if (windows.length)
+        spec.windows = windows;
+    const band = rec.duration_band;
+    if (band && typeof band === "object" && Number(band.min_sec) > 0 && Number(band.max_sec) > Number(band.min_sec)) {
+        spec.duration_band = {
+            min_sec: Number(band.min_sec),
+            max_sec: Number(band.max_sec),
+            target_sec: Number(band.target_sec) > 0 ? Number(band.target_sec) : (Number(band.min_sec) + Number(band.max_sec)) / 2
+        };
+    }
+    else {
+        const target = Number(rec.target_duration_sec ?? rec.duration_sec ?? rec.clip_duration_sec);
+        const resolved = resolveDurationBand(target);
+        if (resolved)
+            spec.duration_band = resolved;
+    }
+    const aspect = normalizeAspect(rec.aspect ?? rec.aspect_ratio ?? rec.orientation);
+    if (aspect)
+        spec.aspect = aspect;
+    if (rec.crop_focus != null)
+        spec.crop_focus = normalizeCropFocus(rec.crop_focus);
+    // Explicit true/false both honored so a caller can opt OUT of the avoid-text
+    // default; only an absent field falls through to applyHuntSpecDefaults.
+    if (rec.avoid_text === true || rec.no_text === true || rec.no_captions === true)
+        spec.avoid_text = true;
+    else if (rec.avoid_text === false || rec.no_text === false || rec.allow_text === true)
+        spec.avoid_text = false;
+    const maxClips = Number(rec.max_clips ?? rec.clip_count ?? rec.target_clip_count);
+    if (Number.isFinite(maxClips) && maxClips > 0)
+        spec.max_clips = Math.min(500, Math.round(maxClips));
+    const perTen = Number(rec.clips_per_10min ?? rec.clips_per_10_min ?? rec.density);
+    if (Number.isFinite(perTen) && perTen > 0)
+        spec.clips_per_10min = Math.min(200, perTen);
+    if (typeof rec.source_url === "string" && rec.source_url.trim())
+        spec.source_url = rec.source_url.trim();
+    if (typeof rec.folder_path === "string" && rec.folder_path.trim())
+        spec.folder_path = rec.folder_path.trim().slice(0, 500);
+    if (rec.audio_only === true || rec.audioOnly === true)
+        spec.audio_only = true;
+    return spec;
+}
+// ── misc ────────────────────────────────────────────────────────────────────
+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) };
+}
+function round1(n) {
+    return Math.round(n * 10) / 10;
+}
+function round3(n) {
+    return Math.round(n * 1000) / 1000;
+}
+//# sourceMappingURL=hunt.js.map

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

@@ -0,0 +1,19 @@
+// vidfarm clip-curation core — the shared "third pillar" library consumed by
+// devcli (local), the Hono API (src/app.ts), and the cloud scan Lambdas. Build
+// once, use in both targets (handoff: Shared Components).
+export * from "./types.js";
+export { ACTIVE_TAXONOMY_VERSION, MULTI_VALUE_CATEGORIES, getTaxonomy, sanitizeTagValues, taxonomyForPrompt } from "./taxonomy.js";
+export { BUILTIN_PRESETS, findBuiltinPreset } from "./presets.js";
+export { ClipModelClient, ClipGeminiClient, ClipEmbeddingClient, EMBEDDING_DIM, EMBEDDING_MODEL, EMBEDDING_MODELS, TAG_MODEL_BY_TIER, buildClipEmbeddingText, buildQueryPrompt, buildTaggingPrompt, normalize } from "./gemini.js";
+export { LocalAgentClipClient, detectLocalAgent, extractJsonObject } from "./local-agent.js";
+export { AVOID_TEXT_GUIDANCE, DEFAULT_CLIP_ASPECT, DEFAULT_CLIP_DURATION_BAND, DEFAULT_CLIPS_PER_10_MIN, applyHuntSpecDefaults, applyUserContentTypeHints, buildEffectiveGuidance, buildPrivateUserNotesGuidance, capScenesEvenlyToCount, cropFilterFor, effectiveHuntDurationSec, extractUserContentTypeHints, fitScenesToDurationBand, normalizeAspect, normalizeCropFocus, normalizeHuntSpec, normalizeWindows, parseClipHuntPrompt, parseTimecode, parseTimeRanges, resolveDurationBand, resolveTargetClipCount } from "./hunt.js";
+export { detectScenes, extractAudioClip, extractClip, extractKeyframes, extractSceneAudio, extractThumbnail, extractWaveformThumbnail, hasFfmpeg, probeVideo, resolveFfmpeg, resolveFfprobe } from "./ffmpeg.js";
+export { cosineSimilarity, matchesCriteria, rankHits, scoreClip, searchClips, structuredMatchRatio } from "./query.js";
+export { estimateScanCostFromDuration, estimateScanCostFromScenes, formatCostEstimate } from "./cost.js";
+export { processSceneToClip, scanVideo } from "./scan.js";
+export { refineScenesWithGuidance } from "./refine.js";
+export { estimateMediaHeight, pickBestVideoMedia, rankPlayableVideoMedias, fetchFirstDownloadableMedia } from "./media-select.js";
+export { deriveMediaNameFromUrl, resolveRawSourceName, slugifyFolderName } from "./source-naming.js";
+// Re-export ClipPreset-related helpers already covered by ./presets and ./types
+// via the wildcard exports above; nothing extra needed here.
+//# sourceMappingURL=index.js.map