@mevdragon/vidfarm-devcli 0.20.5 → 0.20.8

package/dist/src/services/elevenlabs.js

@@ -1,222 +0,0 @@
-// ElevenLabs audio provider (music, TTS, STT) — shared by the ProviderService
-// wallet/BYOK router and the primitive handlers. ElevenLabs is a SPECIAL
-// audio-only provider: it never counts as a qualified text/image/video key.
-// Two ways a call reaches here:
-//   1. Platform key (config.ELEVENLABS_API_KEY) + wallet billing — the default
-//      "use_wallet_credits" path, so good speech/music work with zero setup.
-//   2. The customer's own saved ElevenLabs key (use_wallet_credits: false) — no
-//      wallet charge; identity/voices are scoped to THEIR ElevenLabs account.
-//
-// Keep the raw request/response shapes here — one implementation for cloud and
-// devcli, mirroring services/speech.ts for the openai/gemini/openrouter family.
-import { ProviderAuthError, rateLimitOrQuotaError } from "./provider-errors.js";
-import { pcm16MonoToWav } from "./speech.js";
-const ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
-// Sensible defaults so a bare `music`/`tts` call just works.
-export const DEFAULT_ELEVENLABS_TTS_MODEL = "eleven_multilingual_v2";
-export const DEFAULT_ELEVENLABS_STT_MODEL = "scribe_v1";
-export const DEFAULT_ELEVENLABS_MUSIC_MODEL = "music_v2";
-// George — a warm, versatile narrative voice. Callers can override with any
-// voice_id from `elevenLabsListVoices` (platform or their own account).
-export const DEFAULT_ELEVENLABS_VOICE_ID = "JBFqnCBsd6RMkjVDRZzb";
-export const ELEVENLABS_VOICE_LIBRARY_URL = "https://elevenlabs.io/app/voice-library";
-// A tiny friendly-name → voice_id map so agents/users can say "sarah" instead of
-// an opaque id. Unknown values are passed through untouched (treated as a
-// voice_id), and the real catalog is always `elevenLabsListVoices`.
-const ELEVENLABS_VOICE_PRESETS = {
-    george: "JBFqnCBsd6RMkjVDRZzb",
-    sarah: "EXAVITQu4vr4xnSDxMaL",
-    daniel: "onwK4e9ZLuTAKqWW03F9",
-    charlotte: "XB0fDUnXU5powFXDhCwa",
-    rachel: "21m00Tcm4TlvDq8ikWAM"
-};
-/** Resolve a caller-supplied voice (friendly preset name or raw id) to a voice_id. */
-export function resolveElevenLabsVoiceId(voice) {
-    const raw = voice?.trim();
-    if (!raw) {
-        return DEFAULT_ELEVENLABS_VOICE_ID;
-    }
-    return ELEVENLABS_VOICE_PRESETS[raw.toLowerCase()] ?? raw;
-}
-function authHeaders(apiKey) {
-    return { "xi-api-key": apiKey };
-}
-async function throwForStatus(provider, operation, response) {
-    if (response.status === 401 || response.status === 403) {
-        throw new ProviderAuthError("elevenlabs authentication failed");
-    }
-    if (response.status === 429) {
-        throw await rateLimitOrQuotaError(provider, response);
-    }
-    const details = await response.text().catch(() => "");
-    throw new Error(`elevenlabs ${operation} returned ${response.status}${details ? `: ${details.slice(0, 400)}` : ""}`);
-}
-/** Cheap credential probe — the ElevenLabs equivalent of a chat-completion validate. */
-export async function validateElevenLabsKey(apiKey) {
-    const response = await fetch(`${ELEVENLABS_BASE_URL}/user`, { headers: authHeaders(apiKey) });
-    if (response.ok) {
-        return;
-    }
-    await throwForStatus("elevenlabs", "key validation", response);
-}
-/** List voices available to whichever account owns `apiKey` (platform or the user's). */
-export async function elevenLabsListVoices(apiKey) {
-    const response = await fetch(`${ELEVENLABS_BASE_URL}/voices`, { headers: authHeaders(apiKey) });
-    if (!response.ok) {
-        await throwForStatus("elevenlabs", "list voices", response);
-    }
-    const data = (await response.json());
-    return (data.voices ?? []).map((voice) => ({
-        voice_id: String(voice.voice_id ?? ""),
-        name: String(voice.name ?? "Unnamed"),
-        category: typeof voice.category === "string" ? voice.category : null,
-        description: typeof voice.description === "string" && voice.description.trim() ? voice.description.trim() : null,
-        labels: voice.labels && typeof voice.labels === "object"
-            ? Object.fromEntries(Object.entries(voice.labels).map(([key, value]) => [key, String(value)]))
-            : {},
-        preview_url: typeof voice.preview_url === "string" ? voice.preview_url : null
-    })).filter((voice) => voice.voice_id);
-}
-/** ElevenLabs text-to-speech. `voice` is a voice_id (or a friendly preset name). */
-export async function elevenLabsTextToSpeech(input) {
-    const voiceId = resolveElevenLabsVoiceId(input.voice);
-    const model = input.model?.trim() || DEFAULT_ELEVENLABS_TTS_MODEL;
-    const wantWav = input.responseFormat === "wav";
-    // ElevenLabs has no direct "wav" output — request raw PCM and wrap it in a WAV
-    // header, mirroring the gemini/openrouter PCM bridge in services/speech.ts.
-    const outputFormat = wantWav ? "pcm_44100" : "mp3_44100_128";
-    const voiceSettings = {};
-    if (input.stability != null)
-        voiceSettings.stability = input.stability;
-    if (input.similarityBoost != null)
-        voiceSettings.similarity_boost = input.similarityBoost;
-    if (input.style != null)
-        voiceSettings.style = input.style;
-    if (input.speed != null)
-        voiceSettings.speed = input.speed;
-    const response = await fetch(`${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(voiceId)}?output_format=${outputFormat}`, {
-        method: "POST",
-        headers: { ...authHeaders(input.apiKey), "Content-Type": "application/json" },
-        body: JSON.stringify({
-            text: input.text,
-            model_id: model,
-            ...(input.languageCode ? { language_code: input.languageCode } : {}),
-            ...(Object.keys(voiceSettings).length ? { voice_settings: voiceSettings } : {})
-        })
-    });
-    if (!response.ok) {
-        await throwForStatus("elevenlabs", "text-to-speech", response);
-    }
-    const raw = Buffer.from(await response.arrayBuffer());
-    const bytes = wantWav ? pcm16MonoToWav(raw, 44100) : raw;
-    return {
-        bytes,
-        contentType: wantWav ? "audio/wav" : "audio/mpeg",
-        characterCount: input.text.length,
-        usage: { inputTokens: input.text.length, outputTokens: 0, costUsd: 0 }
-    };
-}
-/** ElevenLabs music generation from a prompt or a hand-built composition plan. */
-export async function elevenLabsMusicCompose(input) {
-    const model = input.model?.trim() || DEFAULT_ELEVENLABS_MUSIC_MODEL;
-    const outputFormat = input.outputFormat?.trim() || "mp3_44100_128";
-    const body = { model_id: model };
-    if (input.compositionPlan) {
-        body.composition_plan = input.compositionPlan;
-    }
-    else {
-        body.prompt = input.prompt;
-        body.music_length_ms = input.musicLengthMs ?? 30000;
-    }
-    const response = await fetch(`${ELEVENLABS_BASE_URL}/music?output_format=${encodeURIComponent(outputFormat)}`, {
-        method: "POST",
-        headers: { ...authHeaders(input.apiKey), "Content-Type": "application/json" },
-        body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-        await throwForStatus("elevenlabs", "music generation", response);
-    }
-    return {
-        bytes: Buffer.from(await response.arrayBuffer()),
-        contentType: "audio/mpeg",
-        musicLengthMs: input.musicLengthMs ?? 30000
-    };
-}
-/** ElevenLabs speech-to-text (Scribe) — native diarization + word timestamps. */
-export async function elevenLabsSpeechToText(input) {
-    const model = input.model?.trim() || DEFAULT_ELEVENLABS_STT_MODEL;
-    const form = new FormData();
-    form.set("file", new Blob([Buffer.from(input.audio)], { type: input.contentType ?? "audio/mpeg" }), "audio");
-    form.set("model_id", model);
-    form.set("diarize", String(input.diarize !== false));
-    form.set("timestamps_granularity", "word");
-    if (input.languageCode) {
-        form.set("language_code", input.languageCode);
-    }
-    if (input.numSpeakers != null) {
-        form.set("num_speakers", String(input.numSpeakers));
-    }
-    const response = await fetch(`${ELEVENLABS_BASE_URL}/speech-to-text`, {
-        method: "POST",
-        headers: authHeaders(input.apiKey),
-        body: form
-    });
-    if (!response.ok) {
-        await throwForStatus("elevenlabs", "speech-to-text", response);
-    }
-    const data = (await response.json());
-    const words = Array.isArray(data.words) ? data.words : [];
-    const segments = groupElevenLabsWordsIntoSegments(words);
-    const speakers = new Set(segments.map((segment) => segment.speaker));
-    const audioDurationSec = words.reduce((max, word) => Math.max(max, Number(word.end ?? 0)), 0) || null;
-    return {
-        text: String(data.text ?? "").trim(),
-        language: typeof data.language_code === "string" && data.language_code.trim() ? data.language_code.trim() : null,
-        segments,
-        diarization: speakers.size > 1 ? "diarized" : "none",
-        usage: { inputTokens: 0, outputTokens: 0, costUsd: 0 },
-        audioDurationSec
-    };
-}
-// Fold ElevenLabs' flat word stream (each tagged with a speaker_id) into
-// speaker-turn segments carrying word-level timings — the shape STT callers and
-// the caption builder already consume.
-function groupElevenLabsWordsIntoSegments(words) {
-    const segments = [];
-    let current = null;
-    let currentWords = [];
-    const flush = () => {
-        if (current) {
-            current.text = current.text.trim();
-            if (currentWords.length) {
-                current.words = currentWords;
-            }
-            if (current.text) {
-                segments.push(current);
-            }
-        }
-        current = null;
-        currentWords = [];
-    };
-    for (const word of words) {
-        if (word.type && word.type !== "word" && word.type !== "spacing") {
-            continue;
-        }
-        const speaker = word.speaker_id?.trim() || "speaker_1";
-        const text = String(word.text ?? "");
-        if (!current || current.speaker !== speaker) {
-            flush();
-            current = { speaker, start_sec: Number(word.start ?? 0), end_sec: Number(word.end ?? 0), text: "" };
-            currentWords = [];
-        }
-        current.text += text;
-        current.end_sec = Number(word.end ?? current.end_sec ?? 0);
-        const trimmed = text.trim();
-        if (trimmed && Number.isFinite(Number(word.start)) && Number.isFinite(Number(word.end))) {
-            currentWords.push({ text: trimmed, start_sec: Number(word.start), end_sec: Number(word.end) });
-        }
-    }
-    flush();
-    return segments;
-}
-//# sourceMappingURL=elevenlabs.js.map

package/dist/src/services/file-directory.js

@@ -1,117 +0,0 @@
-// Shared canonical file-directory path model.
-//
-// The user's files live in three *separate* backends — My Files attachments,
-// Temp files, and the Raws (clip) library — each with its own DynamoDB records
-// and S3 prefix. This module is the ONE place that defines the unified virtual
-// directory that presents them as three navigable roots:
-//
-//     /files/<subfolders…>/<name>     → My Files attachments  (users/<id>/files/…)
-//     /temp/<YYYY-MM-DD>/<name>        → Temp files            (users/<id>/temporary/…)
-//     /raws/<subfolders…>/<name>      → Raws / clip library   (clips/<owner>/…)
-//     /projects/<forkId>/<subpath…>   → Composition forks     (compositions/forks/<forkId>/…)
-//
-// It's a *virtual* layer: physical S3 keys are untouched. The canonical path is
-// what the UI copies, what the chat agent navigates, and what search annotates.
-// A file's real handle is still its backend id (attachment/temp/clip id) — the
-// path is the human-readable navigation + display layer on top.
-//
-// Pure logic, no runtime deps, so both `src/app.ts` (serve) and
-// `infra/lambda/editor-chat.ts` (cloud) import it, and the frontend explorer
-// client mirrors the same constants.
-export const DIRECTORY_ROOT_KEYS = ["files", "temp", "raws", "projects", "approved"];
-export const DIRECTORY_ROOTS = [
-    { key: "files", label: "My Files", description: "Durable personal files — brand assets, characters, saved context. Vector-searchable via notes." },
-    { key: "temp", label: "Temp", description: "Scratch space, auto-organized by date (YYYY-MM-DD) and auto-deleted after 30 days." },
-    { key: "raws", label: "Raws", description: "The reusable clip / source-footage library, organized into folders by source." },
-    { key: "projects", label: "Projects", description: "Your video-editing projects — one folder per fork, holding that composition's working files (composition.html/json, cast, media) and saved versions. Read-only: browse to reference or study another fork." },
-    { key: "approved", label: "Approved", description: "Finished, ready-to-post cuts, organized into folders (defaults to a folder per tracer/campaign)." }
-];
-// The attachments backend historically scopes its folders under the internal
-// key "my_files"; the canonical public root name is "files". These two helpers
-// bridge the canonical name and that backend scope so callers never hardcode it.
-export const ATTACHMENTS_FOLDER_SCOPE = "my_files";
-export function isDirectoryRoot(value) {
-    return value === "files" || value === "temp" || value === "raws" || value === "projects" || value === "approved";
-}
-export function directoryRootLabel(root) {
-    const info = DIRECTORY_ROOTS.find((r) => r.key === root);
-    return info ? info.label : root;
-}
-/**
- * Normalize a relative folder path: trim each segment, drop empties and any
- * leading/trailing slashes, collapse repeats. `"/a//b/ "` → `"a/b"`.
- */
-export function normalizeFolderPath(value) {
-    return String(value ?? "")
-        .split("/")
-        .map((s) => s.trim())
-        .filter(Boolean)
-        .join("/");
-}
-/**
- * Parse a canonical directory path into its root + relative folder path.
- *
- * A path is always interpreted as a FOLDER location (what to list / scope to):
- * every segment after the root is treated as folder path. Files are addressed
- * by backend id, not resolved from the trailing segment, so there's no
- * file-vs-folder ambiguity to guess at here.
- *
- *   "/raws/product-demos"  → { root:"raws", folderPath:"product-demos" }
- *   "/"  or  ""            → { root:null,   folderPath:"" }  (virtual root)
- */
-export function parseDirectoryPath(input) {
-    const segments = String(input ?? "")
-        .split("/")
-        .map((s) => s.trim())
-        .filter(Boolean);
-    if (segments.length === 0)
-        return { root: null, folderPath: "", segments: [] };
-    const [head, ...rest] = segments;
-    if (!isDirectoryRoot(head))
-        return { root: null, folderPath: "", segments };
-    return { root: head, folderPath: rest.join("/"), segments: rest };
-}
-/**
- * Build a canonical directory path from parts. `name` omitted → a folder path.
- *
- *   buildDirectoryPath("files", "logos", "logo.png") → "/files/logos/logo.png"
- *   buildDirectoryPath("raws", "demos")              → "/raws/demos"
- *   buildDirectoryPath("temp")                       → "/temp"
- */
-export function buildDirectoryPath(root, folderPath, name) {
-    const parts = [root, normalizeFolderPath(folderPath)];
-    if (name)
-        parts.push(String(name).trim());
-    return "/" + parts.filter(Boolean).join("/");
-}
-/** Build a folder DirectoryItem for a child folder name under a root/parent. */
-export function folderItem(root, parentFolder, childName) {
-    const folderPath = normalizeFolderPath(parentFolder ? `${parentFolder}/${childName}` : childName);
-    return {
-        path: buildDirectoryPath(root, folderPath),
-        root,
-        folderPath,
-        name: childName,
-        kind: "folder"
-    };
-}
-/**
- * Given a flat list of items' folderPaths (+ any explicit empty-folder records)
- * and the current folder, return the immediate CHILD folder names. Mirrors the
- * client explorer's `immediateFolders`, kept here so server and client agree.
- */
-export function immediateChildFolders(folderPaths, currentFolder) {
-    const cur = normalizeFolderPath(currentFolder);
-    const prefix = cur ? cur + "/" : "";
-    const names = new Set();
-    for (const raw of folderPaths) {
-        const n = normalizeFolderPath(raw);
-        if (!n || (cur && n === cur) || n.indexOf(prefix) !== 0)
-            continue;
-        const child = n.slice(prefix.length).split("/")[0];
-        if (child)
-            names.add(child);
-    }
-    return Array.from(names).sort();
-}
-//# sourceMappingURL=file-directory.js.map

package/dist/src/services/fork-access.js

@@ -1,93 +0,0 @@
-import { serverlessRecords } from "./serverless-records.js";
-export class ForkNotFoundError extends Error {
-    constructor() { super("Fork not found"); this.name = "ForkNotFoundError"; }
-}
-export class ForkAccessDeniedError extends Error {
-    needed;
-    constructor(needed) {
-        super(`Missing required capability: ${needed}`);
-        this.needed = needed;
-        this.name = "ForkAccessDeniedError";
-    }
-}
-const capabilitiesByRole = {
-    viewer: { canView: true, canEdit: false, canPublish: false },
-    editor: { canView: true, canEdit: true, canPublish: false },
-    publisher: { canView: true, canEdit: true, canPublish: true }
-};
-function ownerCaps() {
-    return { isOwner: true, canView: true, canEdit: true, canPublish: true, canShare: true, canDelete: true, role: "owner" };
-}
-function fromRole(role) {
-    return {
-        isOwner: false,
-        ...capabilitiesByRole[role],
-        canShare: false,
-        canDelete: false,
-        role
-    };
-}
-function mergeCaps(a, b) {
-    const stronger = roleStrength(a.role) >= roleStrength(b.role) ? a : b;
-    return {
-        isOwner: a.isOwner || b.isOwner,
-        canView: a.canView || b.canView,
-        canEdit: a.canEdit || b.canEdit,
-        canPublish: a.canPublish || b.canPublish,
-        canShare: a.canShare || b.canShare,
-        canDelete: a.canDelete || b.canDelete,
-        role: stronger.role
-    };
-}
-function roleStrength(role) {
-    switch (role) {
-        case "owner": return 4;
-        case "publisher": return 3;
-        case "editor": return 2;
-        case "viewer": return 1;
-        default: return 0;
-    }
-}
-function isExpired(expiresAt) {
-    if (!expiresAt)
-        return false;
-    return new Date(expiresAt).getTime() < Date.now();
-}
-export async function resolveForkAccess(input) {
-    const fork = await serverlessRecords.getCompositionFork(input.forkId);
-    if (!fork || fork.deletedAt) {
-        throw new ForkNotFoundError();
-    }
-    // Fork content lives under a public-read S3 prefix — any client with the
-    // fork_id can already fetch composition.html/json/manifest.json directly
-    // from S3. Reflect that reality in the API so read endpoints don't lie
-    // about protecting content that isn't actually protected. Edit/publish/
-    // share/delete stay gated below.
-    let caps = fromRole("viewer");
-    if (input.customerId && fork.customerId === input.customerId) {
-        caps = mergeCaps(caps, ownerCaps());
-    }
-    if (input.customerId) {
-        const allPerms = await serverlessRecords.listForkPermissions(fork.id);
-        const granted = allPerms.filter((perm) => perm.granteeType === "customer" && perm.granteeId === input.customerId && !isExpired(perm.expiresAt));
-        for (const perm of granted) {
-            caps = mergeCaps(caps, fromRole(perm.role));
-        }
-    }
-    if (input.shareToken) {
-        const link = await serverlessRecords.getForkShareLinkByToken(input.shareToken);
-        if (link && link.forkId === fork.id && !link.revokedAt && !isExpired(link.expiresAt)) {
-            caps = mergeCaps(caps, fromRole(link.role));
-        }
-    }
-    return { fork, capabilities: caps };
-}
-export async function assertForkAccess(input, required) {
-    const result = await resolveForkAccess(input);
-    const need = `can${required[0].toUpperCase()}${required.slice(1)}`;
-    if (!result.capabilities[need]) {
-        throw new ForkAccessDeniedError(need);
-    }
-    return result;
-}
-//# sourceMappingURL=fork-access.js.map

package/dist/src/services/fork-manifest.js

@@ -1,42 +0,0 @@
-function buildManifest(storage, fork, target) {
-    const isWorking = target.kind === "working";
-    const htmlKey = isWorking
-        ? storage.compositionForkWorkingKey(fork.id, "composition.html")
-        : storage.compositionForkVersionKey(fork.id, target.version, "composition.html");
-    const jsonKey = isWorking
-        ? storage.compositionForkWorkingKey(fork.id, "composition.json")
-        : storage.compositionForkVersionKey(fork.id, target.version, "composition.json");
-    const manifestKey = isWorking
-        ? storage.compositionForkWorkingKey(fork.id, "manifest.json")
-        : storage.compositionForkVersionKey(fork.id, target.version, "manifest.json");
-    const parentManifestKey = fork.parentForkId && fork.parentVersion
-        ? storage.compositionForkVersionKey(fork.parentForkId, fork.parentVersion, "manifest.json")
-        : null;
-    return {
-        fork_id: fork.id,
-        customer_id: fork.customerId,
-        is_working: isWorking,
-        version: isWorking ? null : target.version,
-        latest_version: fork.latestVersion,
-        parent_fork_id: fork.parentForkId,
-        parent_version: fork.parentVersion,
-        template_id: fork.templateId,
-        visibility: fork.visibility,
-        title: fork.title,
-        composition_url: storage.getPublicUrl(htmlKey),
-        composition_json_url: storage.getPublicUrl(jsonKey),
-        manifest_url: storage.getPublicUrl(manifestKey),
-        parent_manifest_url: parentManifestKey ? storage.getPublicUrl(parentManifestKey) : null,
-        created_at: !isWorking && target.kind === "version" && target.createdAt ? target.createdAt : fork.createdAt,
-        updated_at: fork.updatedAt
-    };
-}
-export async function writeForkManifest(storage, fork, target) {
-    const manifest = buildManifest(storage, fork, target);
-    const key = target.kind === "working"
-        ? storage.compositionForkWorkingKey(fork.id, "manifest.json")
-        : storage.compositionForkVersionKey(fork.id, target.version, "manifest.json");
-    await storage.putJson(key, manifest);
-    return manifest;
-}
-//# sourceMappingURL=fork-manifest.js.map

package/dist/src/services/ghostcut.js

@@ -1,179 +0,0 @@
-import { createHash } from "node:crypto";
-import { config } from "../config.js";
-const BASE_URL = "https://api.zhaoli.com";
-export function isGhostcutConfigured() {
-    return Boolean(config.GHOSTCUT_KEY && config.GHOSTCUT_SECRET);
-}
-// GhostCut bills per 30-second chunk with a 1-chunk minimum. A 45s clip is
-// 2 chunks, a 90s clip is 3. Rate defaults to $0.10 per chunk but can be
-// overridden via GHOSTCUT_USD_PER_30S.
-export function estimateGhostcutCostUsd(durationSeconds) {
-    const usdPerChunk = config.GHOSTCUT_USD_PER_30S;
-    const positiveSeconds = Number.isFinite(durationSeconds) && durationSeconds > 0 ? durationSeconds : 30;
-    const chunks = Math.max(1, Math.ceil(positiveSeconds / 30));
-    const usd = Number((chunks * usdPerChunk).toFixed(4));
-    return { chunks, usd, usdPerChunk };
-}
-function md5Hex(input) {
-    return createHash("md5").update(input).digest("hex");
-}
-async function ghostcutPost(path, payload, signal) {
-    if (!config.GHOSTCUT_KEY || !config.GHOSTCUT_SECRET) {
-        throw new Error("GhostCut credentials not configured");
-    }
-    const body = JSON.stringify(payload);
-    const sign = md5Hex(md5Hex(body) + config.GHOSTCUT_SECRET);
-    const response = await fetch(`${BASE_URL}${path}`, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            AppKey: config.GHOSTCUT_KEY,
-            AppSign: sign
-        },
-        body,
-        signal
-    });
-    if (!response.ok) {
-        throw new Error(`GhostCut HTTP ${response.status} ${response.statusText}`);
-    }
-    return (await response.json());
-}
-// Submits a subtitle-removal task using GhostCut's Basic text-removal model.
-// We deliberately do NOT pass `extra_inpaint_config.model` — that would opt
-// into one of the Advanced tiers (Lite/Pro/Full), which are:
-//   1. More expensive per 30s chunk
-//   2. Require `videoInpaintMasks` to be supplied — advanced_lite in particular
-//      rejects with processStatus=26 / ValidationError
-//      ("video_inpaint_masks is not set") when no mask is passed
-// Basic is the cheapest tier and handles hardcoded TikTok-style captions fine
-// without requiring us to hand-crop a mask region for every video.
-//
-// needChineseOcclude=3 = "Automatically remove moving text". Per the docs this
-// is the smart mode that only touches AI-detected text and leaves backgrounds
-// alone — exactly what TikTok-style dynamic burned-in captions need. Mode 1
-// (full-screen inpainting) is more aggressive; mode 3 sidesteps that class of
-// failure while still catching the burned-in subtitles.
-// Returns quickly (<2s). Throws on non-1000 response codes (auth, credits, etc).
-export async function submitSubtitleRemoval(sourceUrl, signal) {
-    const payload = {
-        urls: [sourceUrl],
-        needChineseOcclude: 3,
-        videoInpaintLang: "all"
-    };
-    const res = await ghostcutPost("/v-w-c/gateway/ve/work/free", payload, signal);
-    if (res.code !== 1000) {
-        throw new Error(`GhostCut submit failed: code=${res.code} msg=${res.msg ?? "unknown"}`);
-    }
-    const taskId = res.body?.idProject ??
-        res.body?.dataList?.[0]?.idProject ??
-        res.body?.dataList?.[0]?.id;
-    if (typeof taskId !== "number") {
-        throw new Error(`GhostCut response missing task id: ${JSON.stringify(res)}`);
-    }
-    return { taskId };
-}
-export async function pollStatus(taskId, signal) {
-    const res = await ghostcutPost("/v-w-c/gateway/ve/work/status", { idProjects: [taskId] }, signal);
-    if (res.code !== 1000) {
-        return { state: "failed", reason: `status code=${res.code}` };
-    }
-    const entry = res.body?.content?.[0];
-    if (!entry) {
-        return { state: "queued", progress: 0 };
-    }
-    const processStatus = Number(entry.processStatus ?? 0);
-    const progress = Number(entry.processProgress ?? 0);
-    // GhostCut's canonical live states: 1 = done, 0 = processing, -2 = queued.
-    // Everything else is a terminal error condition. Notable codes we've hit
-    // in the wild: -1/2/3 (generic failure), 73 (insufficient points — account
-    // out of credits, task will NEVER progress). Treat all non-live codes as
-    // failed so we stop polling and fall back to the original video instead
-    // of spinning forever.
-    if (processStatus === 1) {
-        const rawUrl = entry.videoUrl ?? entry.videoUrls;
-        const videoUrl = Array.isArray(rawUrl) ? String(rawUrl[0] ?? "") : String(rawUrl ?? "");
-        if (!videoUrl)
-            return { state: "failed", reason: "processStatus=1 but no videoUrl" };
-        return { state: "done", videoUrl, progress: 100 };
-    }
-    if (processStatus === 0) {
-        return { state: "processing", progress };
-    }
-    if (processStatus === -2) {
-        return { state: "queued", progress };
-    }
-    // Any other code is terminal-failure. Assemble the most helpful reason
-    // string GhostCut gives us, in priority order:
-    //   1. processStatusEnum.descriptionEn — official English label for the code
-    //   2. errorDetail — long-form failure message ("Video too short", etc.)
-    //   3. errorMsg — short label
-    //   4. compact raw entry dump — fallback so unknown codes still capture
-    //      whatever fields GhostCut populated, letting us reverse-engineer
-    //      new failure modes without a second API round-trip.
-    // The Appendix A enum table (Feishu-only) isn't public, so relying on
-    // GhostCut's own free-text fields is the only way to name codes like 26.
-    const enumObj = entry.processStatusEnum;
-    const enumEn = typeof enumObj?.descriptionEn === "string" ? enumObj.descriptionEn.trim() : "";
-    const errorDetail = typeof entry.errorDetail === "string" ? entry.errorDetail.trim() : "";
-    const errorMsg = typeof entry.errorMsg === "string" ? entry.errorMsg.trim() : "";
-    const parts = [];
-    if (enumEn)
-        parts.push(enumEn);
-    if (errorDetail && errorDetail !== enumEn)
-        parts.push(`detail=${errorDetail}`);
-    if (errorMsg && errorMsg !== enumEn && errorMsg !== errorDetail)
-        parts.push(`msg=${errorMsg}`);
-    if (parts.length === 0) {
-        // Nothing human-readable — dump the raw payload so operators can still see
-        // whatever GhostCut *did* send back.
-        return { state: "failed", reason: `processStatus=${processStatus} raw=${safeCompactJson(entry, 500)}` };
-    }
-    return { state: "failed", reason: `processStatus=${processStatus} ${parts.join(" ")}` };
-}
-// Best-effort compact stringifier — clamps the output so a huge GhostCut
-// entry doesn't blow up the log line, and falls back to a marker string
-// when serialization itself fails (circular refs shouldn't happen but
-// defense-in-depth for JSON.stringify).
-function safeCompactJson(value, maxLen) {
-    try {
-        const raw = JSON.stringify(value);
-        if (raw.length <= maxLen)
-            return raw;
-        return `${raw.slice(0, maxLen)}…(+${raw.length - maxLen}b)`;
-    }
-    catch {
-        return "<unserializable>";
-    }
-}
-// Polls GhostCut until the task is done, fails, or the timeout expires.
-// Throws on failure/timeout — callers use that to fall back to the original video.
-export async function waitForCompletion(taskId, opts) {
-    const started = Date.now();
-    const pollIntervalMs = opts.pollIntervalMs ?? 5000;
-    while (true) {
-        if (opts.signal?.aborted)
-            throw new Error("GhostCut wait aborted");
-        const remaining = opts.timeoutMs - (Date.now() - started);
-        if (remaining <= 0)
-            throw new Error(`GhostCut task ${taskId} timed out`);
-        const status = await pollStatus(taskId, opts.signal);
-        if (status.state === "done")
-            return { videoUrl: status.videoUrl };
-        if (status.state === "failed")
-            throw new Error(`GhostCut task ${taskId} failed: ${status.reason}`);
-        await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
-    }
-}
-// Downloads the GhostCut-hosted result and mirrors it to our S3 bucket so
-// composition HTML can point at a stable URL under our control (rather than a
-// short-lived third-party CDN link).
-export async function mirrorGhostcutVideoToStorage(input) {
-    const response = await fetch(input.videoUrl, { signal: input.signal });
-    if (!response.ok) {
-        throw new Error(`Failed to fetch GhostCut result: HTTP ${response.status}`);
-    }
-    const arrayBuffer = await response.arrayBuffer();
-    const result = await input.storage.putBuffer(input.key, Buffer.from(arrayBuffer), "video/mp4");
-    return { key: result.key, publicUrl: result.url };
-}
-//# sourceMappingURL=ghostcut.js.map