@mevdragon/vidfarm-devcli 0.20.6 → 0.20.9

package/dist/src/primitive-registry.js

@@ -1,3940 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import sharp from "sharp";
-import { z } from "zod";
-import { config } from "./config.js";
-import { definePrimitive } from "./primitive-sdk.js";
-import { PrimitiveMediaLambdaService } from "./services/primitive-media-lambda.js";
-import { estimateGhostcutCostUsd, isGhostcutConfigured, pollStatus as pollGhostcutStatus, submitSubtitleRemoval } from "./services/ghostcut.js";
-import { buildSrtFromSegments, defaultSpeechModelFor, GEMINI_TTS_VOICES, inferSpeechProviderForVoice, OPENAI_TTS_VOICES, speechVoiceFamilyFor, speechVoiceMismatch } from "./services/speech.js";
-import { buildCaptionCues, cuesFromText } from "./services/captions.js";
-import { CAPTION_ANIMATIONS, CAPTION_STYLE_PRESETS, captionStylePresetById } from "./hyperframes/composition.js";
-import { buildHtmlImageCompositionHtml, buildMediaDedupeCompositionHtml, DEDUPE_DEFAULT_EFFECTS } from "./primitives/hyperframes-media.js";
-const imageProviderSchema = z.enum(["openai", "gemini", "openrouter"]);
-const videoProviderSchema = z.enum(["openai", "gemini", "openrouter"]);
-const textProviderSchema = z.enum(["openai", "gemini", "openrouter", "perplexity"]);
-const outputFormatSchema = z.enum(["png", "jpeg", "webp"]);
-const aspectRatioSchema = z.enum(["1:1", "4:3", "3:4", "16:9", "9:16"]).optional();
-const videoAspectRatioSchema = z.enum(["1:1", "4:3", "3:4", "16:9", "9:16", "21:9", "9:21"]).optional();
-const imageSizeSchema = z.enum(["1K", "2K", "4K"]).optional();
-const brainstormCountSchema = z.number().int().min(1).max(50).default(12);
-const generateImagePayloadSchema = z.object({
-    provider: imageProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    prompt: z.string().min(3).max(8000),
-    prompt_attachments: z.array(z.string().url()).max(16).default([]),
-    aspect_ratio: aspectRatioSchema,
-    size: z.string().min(1).max(40).optional(),
-    image_size: imageSizeSchema,
-    output_format: outputFormatSchema.default("png")
-});
-const editImagePayloadSchema = z.object({
-    provider: imageProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    source_image_url: z.string().url(),
-    instruction: z.string().min(3).max(8000),
-    reference_attachments: z.array(z.string().url()).max(15).default([]),
-    aspect_ratio: aspectRatioSchema,
-    size: z.string().min(1).max(40).optional(),
-    image_size: imageSizeSchema,
-    output_format: outputFormatSchema.default("png")
-});
-const inpaintImagePayloadSchema = z.object({
-    provider: imageProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    source_image_url: z.string().url(),
-    mask_url: z.string().url(),
-    instruction: z.string().min(3).max(8000),
-    reference_attachments: z.array(z.string().url()).max(15).default([]),
-    aspect_ratio: aspectRatioSchema,
-    size: z.string().min(1).max(40).optional(),
-    image_size: imageSizeSchema,
-    output_format: outputFormatSchema.default("png")
-});
-const videoFrameImageSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const frame = raw;
-    return {
-        ...frame,
-        image_url: frame.image_url ?? frame.imageUrl,
-        frame_type: frame.frame_type ?? frame.frameType
-    };
-}, z.object({
-    image_url: z.string().url(),
-    frame_type: z.enum(["first_frame", "last_frame"]).default("first_frame")
-}));
-const generateVideoPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    const explicitSeconds = payload.duration ??
-        payload.duration_seconds ??
-        payload.durationSeconds ??
-        payload.seconds ??
-        payload.video_length_seconds ??
-        payload.videoLengthSeconds;
-    const milliseconds = payload.duration_ms ?? payload.durationMs ?? payload.video_length_ms ?? payload.videoLengthMs;
-    return {
-        ...payload,
-        duration: normalizeAiVideoDurationSeconds(explicitSeconds, milliseconds)
-    };
-}, z.object({
-    provider: videoProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    prompt: z.string().min(3).max(8000),
-    duration: z.number().int().min(1).max(30).optional(),
-    resolution: z.enum(["480p", "720p", "1080p", "1K", "2K", "4K"]).optional(),
-    aspect_ratio: videoAspectRatioSchema,
-    size: z.string().min(1).max(40).optional(),
-    generate_audio: z.boolean().optional(),
-    frame_images: z.array(videoFrameImageSchema).max(2).default([]),
-    input_references: z.array(z.string().url()).max(8).default([]),
-    seed: z.number().int().optional(),
-    provider_options: z.record(z.string(), z.unknown()).optional(),
-    output_format: z.enum(["mp4"]).default("mp4")
-}));
-const removeBackgroundImagePayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    return {
-        ...payload,
-        source_image_url: payload.source_image_url ??
-            payload.image_url ??
-            payload.imageUrl ??
-            payload.url
-    };
-}, z.object({
-    source_image_url: z.string().url(),
-    output_format: z.enum(["png", "jpeg", "webp"]).default("webp")
-}));
-// Transparent-capable output only (jpeg has no alpha) for the chroma-key routes.
-const alphaOutputFormatSchema = z.enum(["png", "webp"]).default("png");
-const greenscreenRemoveBackgroundPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const p = raw;
-    return {
-        ...p,
-        source_image_url: p.source_image_url ?? p.image_url ?? p.imageUrl ?? p.url,
-        key_color: p.key_color ?? p.keyColor ?? p.background_color ?? p.backgroundColor ?? p.color,
-        tolerance: p.tolerance ?? p.threshold,
-        softness: p.softness ?? p.feather,
-        despill: p.despill ?? p.spill_suppression ?? p.spillSuppression
-    };
-}, z.object({
-    source_image_url: z.string().url(),
-    // The background color to key out. Green by default; pass white/#FFFFFF,
-    // blue, or any hex/rgb/named color to key a different flat background.
-    key_color: z.string().min(1).max(64).default("#00FF00"),
-    // Base similarity radius (0..1). Larger = more aggressive removal.
-    tolerance: z.coerce.number().min(0).max(1).default(0.3),
-    // Feather band beyond `tolerance` for soft anti-aliased edges (0..1).
-    softness: z.coerce.number().min(0).max(1).default(0.1),
-    // Suppress residual key-color fringe on the subject's edges.
-    despill: z.boolean().default(true),
-    output_format: alphaOutputFormatSchema
-}));
-const mediaOverlayPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const p = raw;
-    return {
-        ...p,
-        key_color: p.key_color ?? p.keyColor ?? p.background_color ?? p.backgroundColor,
-        tolerance: p.tolerance ?? p.threshold,
-        softness: p.softness ?? p.feather,
-        despill: p.despill ?? p.spill_suppression ?? p.spillSuppression,
-        prompt_attachments: p.prompt_attachments ?? p.promptAttachments ?? p.reference_attachments
-    };
-}, z.object({
-    provider: imageProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    prompt: z.string().min(3).max(8000),
-    prompt_attachments: z.array(z.string().url()).max(16).default([]),
-    aspect_ratio: aspectRatioSchema,
-    image_size: imageSizeSchema,
-    key_color: z.string().min(1).max(64).default("#00FF00"),
-    tolerance: z.coerce.number().min(0).max(1).default(0.3),
-    softness: z.coerce.number().min(0).max(1).default(0.1),
-    despill: z.boolean().default(true),
-    output_format: alphaOutputFormatSchema
-}));
-const renderHtmlImagePayloadSchema = z.object({
-    width: z.number().int().min(16).max(4096).default(1080),
-    height: z.number().int().min(16).max(4096).default(1920),
-    html: z.string().min(1).max(200_000),
-    css: z.string().max(200_000).optional(),
-    background_color: z.string().min(1).max(64).default("#ffffff"),
-    output_format: outputFormatSchema.default("png")
-});
-const mediaTypeSchema = z.enum(["image", "video"]);
-const mediaFitSchema = z.enum(["cover", "contain", "fill"]);
-const renderVideoSlideSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const slide = raw;
-    return {
-        ...slide,
-        media_url: slide.media_url ?? slide.image_url ?? slide.imageUrl ?? slide.video_url ?? slide.videoUrl,
-        duration_ms: slide.duration_ms ?? slide.durationMs,
-        media_type: slide.media_type ?? slide.mediaType,
-        background_color: slide.background_color ?? slide.backgroundColor
-    };
-}, z.object({
-    media_url: z.string().url(),
-    media_type: mediaTypeSchema.optional(),
-    duration_ms: z.number().int().min(100).max(120_000),
-    fit: mediaFitSchema.optional(),
-    background_color: z.string().min(1).max(64).optional()
-}));
-const renderSlidesVideoPayloadSchema = z.object({
-    slides: z.array(renderVideoSlideSchema).min(1).max(100),
-    width: z.number().int().min(16).max(4096).default(1080),
-    height: z.number().int().min(16).max(4096).default(1920),
-    background_color: z.string().min(1).max(64).default("#000000"),
-    default_fit: mediaFitSchema.default("cover")
-}).superRefine((value, ctx) => {
-    const totalDurationMs = value.slides.reduce((total, slide) => total + slide.duration_ms, 0);
-    if (totalDurationMs > 10 * 60 * 1000) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Total slideshow duration must be 10 minutes or less.",
-            path: ["slides"]
-        });
-    }
-});
-const dedupeMediaFitSchema = z.enum(["cover", "contain", "fill", "none", "scale-down"]);
-const dedupeEffectsSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const p = raw;
-    return {
-        zoom: p.zoom,
-        tilt: p.tilt,
-        rotate: p.rotate,
-        saturation: p.saturation,
-        speed: p.speed,
-        horizontal_flip: p.horizontal_flip ?? p.horizontalFlip,
-        contrast: p.contrast,
-        brightness: p.brightness,
-        hue_rotate: p.hue_rotate ?? p.hueRotate,
-        blur: p.blur
-    };
-}, z.object({
-    zoom: z.number().min(0.1).max(10).optional(),
-    tilt: z.number().min(-90).max(90).optional(),
-    rotate: z.number().min(-360).max(360).optional(),
-    saturation: z.number().min(0).max(10).optional(),
-    speed: z.number().min(0.1).max(10).optional(),
-    horizontal_flip: z.boolean().optional(),
-    contrast: z.number().min(0).max(10).optional(),
-    brightness: z.number().min(0).max(10).optional(),
-    hue_rotate: z.number().min(-360).max(360).optional(),
-    blur: z.number().min(0).max(50).optional()
-}));
-const mediaDedupePayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const p = raw;
-    return {
-        ...p,
-        source_media_url: p.source_media_url
-            ?? p.source_video_url
-            ?? p.source_image_url
-            ?? p.media_url
-            ?? p.mediaUrl
-            ?? p.url,
-        media_type: p.media_type ?? p.mediaType,
-        tint_color: p.tint_color ?? p.tintColor,
-        tint_opacity: p.tint_opacity ?? p.tintOpacity,
-        duration_ms: p.duration_ms ?? p.durationMs,
-        fallback_duration_ms: p.fallback_duration_ms ?? p.fallbackDurationMs,
-        object_fit: p.object_fit ?? p.objectFit,
-        object_position: p.object_position ?? p.objectPosition,
-        background_color: p.background_color ?? p.backgroundColor,
-        output_format: p.output_format ?? p.outputFormat
-    };
-}, z.object({
-    source_media_url: z.string().url(),
-    media_type: mediaTypeSchema.optional(),
-    effects: dedupeEffectsSchema.optional(),
-    tint_color: z.string().min(1).max(64).default("#FF8C00"),
-    tint_opacity: z.number().min(0).max(1).default(0.08),
-    width: z.number().int().min(16).max(4096).default(1080),
-    height: z.number().int().min(16).max(4096).default(1920),
-    duration_ms: z.number().int().min(100).max(600_000).optional(),
-    fallback_duration_ms: z.number().int().min(100).max(600_000).default(5000),
-    object_fit: dedupeMediaFitSchema.default("cover"),
-    object_position: z.string().min(1).max(64).default("center center"),
-    background_color: z.string().min(1).max(64).default("#000000"),
-    muted: z.boolean().default(false),
-    volume: z.number().min(0).max(2).default(1),
-    output_format: outputFormatSchema.default("png")
-}));
-const hyperframeLayerPayloadSchema = z.object({
-    id: z.string().min(1).max(120),
-    kind: z.enum(["video", "image", "audio", "caption", "text", "html", "shape"]),
-    label: z.string().max(200).optional(),
-    mode: z.enum(["both", "editor", "publish"]).default("publish"),
-    start: z.number().min(0),
-    duration: z.number().positive(),
-    track: z.number().int().min(0).default(0),
-    z: z.number().int().default(0),
-    x: z.number().default(0),
-    y: z.number().default(0),
-    width: z.number().positive().default(100),
-    height: z.number().positive().default(100),
-    src: z.string().min(1).optional(),
-    mediaStart: z.number().min(0).optional(),
-    media_start: z.number().min(0).optional(),
-    playbackStart: z.number().min(0).optional(),
-    playback_start: z.number().min(0).optional(),
-    fit: z.enum(["cover", "contain", "fill", "none"]).default("cover"),
-    muted: z.boolean().optional(),
-    volume: z.number().min(0).max(2).optional(),
-    text: z.string().max(20_000).optional(),
-    html: z.string().max(200_000).optional(),
-    color: z.string().max(80).optional(),
-    background: z.string().max(80).optional(),
-    textBackgroundStyle: z.enum(["plain", "outline", "highlight-solid", "highlight-translucent", "panel"]).optional(),
-    text_background_style: z.enum(["plain", "outline", "highlight-solid", "highlight-translucent", "panel"]).optional(),
-    fontFamily: z.string().max(120).optional(),
-    font_family: z.string().max(120).optional(),
-    fontWeight: z.number().int().min(100).max(1000).optional(),
-    font_weight: z.number().int().min(100).max(1000).optional(),
-    fontSize: z.number().int().min(4).max(400).optional(),
-    font_size: z.number().int().min(4).max(400).optional(),
-    lineHeight: z.number().min(0.5).max(4).optional(),
-    line_height: z.number().min(0.5).max(4).optional(),
-    radius: z.number().min(0).max(999).optional(),
-    opacity: z.number().min(0).max(1).optional(),
-    viralAlignment: z.string().max(2000).optional(),
-    viral_alignment: z.string().max(2000).optional()
-});
-const hyperframesCompositionPayloadSchema = z.object({
-    composition_id: z.string().min(1).max(120),
-    title: z.string().max(200).optional(),
-    source_folder: z.string().max(500).optional(),
-    width: z.number().int().min(16).max(4096).default(720),
-    height: z.number().int().min(16).max(4096).default(1280),
-    fps: z.number().int().min(1).max(120).default(30),
-    duration: z.number().positive().optional(),
-    duration_seconds: z.number().positive().optional(),
-    background_color: z.string().max(80).default("#050604"),
-    css: z.string().max(200_000).optional(),
-    layers: z.array(hyperframeLayerPayloadSchema).min(1).max(300)
-});
-const hyperframesProjectFilePayloadSchema = z.object({
-    path: z.string().min(1).max(500),
-    contents: z.string().max(2_000_000).optional(),
-    source_path: z.string().min(1).max(500).optional(),
-    encoding: z.enum(["utf8", "base64"]).default("utf8"),
-    content_type: z.string().max(120).optional()
-}).refine((value) => Boolean(value.contents || value.source_path), {
-    message: "project_files entry needs contents or source_path."
-});
-function readHyperframesProjectFileContents(file) {
-    if (file.source_path) {
-        const normalized = file.source_path.replace(/^\/+/, "").replace(/\\/g, "/");
-        if (normalized.includes("..") || !normalized.startsWith("drafts/")) {
-            throw new Error(`project_files.source_path must live under drafts/: ${file.source_path}`);
-        }
-        // The JobRunner lambda chdirs to /tmp/vidfarm-job-runner at startup, so
-        // process.cwd() no longer points at the lambda image root. The drafts/
-        // tree is baked into the image at LAMBDA_TASK_ROOT (/var/task).
-        const root = process.env.LAMBDA_TASK_ROOT ?? process.cwd();
-        const resolved = path.resolve(root, normalized);
-        return readFileSync(resolved);
-    }
-    if (file.contents === undefined) {
-        throw new Error("project_files entry has neither contents nor source_path");
-    }
-    return file.encoding === "base64" ? Buffer.from(file.contents, "base64") : file.contents;
-}
-const hyperframesRenderPayloadSchema = z.object({
-    composition_html: z.string().min(1).max(2_000_000).optional(),
-    composition: hyperframesCompositionPayloadSchema.optional(),
-    composition_id: z.string().min(1).max(120).optional(),
-    title: z.string().max(200).optional(),
-    width: z.number().int().min(16).max(4096).optional(),
-    height: z.number().int().min(16).max(4096).optional(),
-    fps: z.number().int().min(1).max(120).default(30),
-    chunk_size: z.number().int().min(1).max(1800).default(240),
-    max_parallel_chunks: z.number().int().min(1).max(40).default(8),
-    output_key: z.string().min(1).max(300).default("output.mp4"),
-    project_files: z.array(hyperframesProjectFilePayloadSchema).max(100).default([]),
-    composition_data: z.record(z.string(), z.unknown()).optional()
-}).refine((value) => Boolean(value.composition_html || value.composition), {
-    message: "Provide either composition_html or composition layers.",
-    path: ["composition_html"]
-});
-const mediaSourceUrlSchema = z.string().url().refine((value) => !isVidfarmControlPlaneArtifactUrl(value), {
-    message: "Pass a direct media URL, such as artifact.public_url, not a Vidfarm job artifacts API endpoint."
-});
-const normalizeVideoPayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema,
-    max_width: z.number().int().min(240).max(4096).default(1080),
-    max_height: z.number().int().min(240).max(4096).default(1920),
-    crf: z.number().int().min(18).max(35).default(23),
-    preset: z.enum(["veryfast", "faster", "fast", "medium"]).default("veryfast"),
-    max_video_bitrate_kbps: z.number().int().min(500).max(50_000).default(8000),
-    audio_bitrate_kbps: z.number().int().min(64).max(320).default(128)
-});
-const trimVideoPayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema,
-    start_ms: z.number().int().min(0).default(0),
-    end_ms: z.number().int().min(1).optional(),
-    duration_ms: z.number().int().min(1).optional(),
-    max_width: z.number().int().min(240).max(4096).optional(),
-    max_height: z.number().int().min(240).max(4096).optional(),
-    crf: z.number().int().min(18).max(35).default(23),
-    preset: z.enum(["veryfast", "faster", "fast", "medium"]).default("veryfast"),
-    audio_bitrate_kbps: z.number().int().min(64).max(320).default(128)
-}).refine((value) => value.duration_ms != null || value.end_ms != null, {
-    message: "Either duration_ms or end_ms is required.",
-    path: ["duration_ms"]
-});
-const extractAudioPayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema,
-    output_format: z.enum(["mp3", "wav", "m4a"]).default("mp3"),
-    audio_bitrate_kbps: z.number().int().min(64).max(320).default(128)
-});
-const trimAudioPayloadSchema = z.object({
-    source_audio_url: mediaSourceUrlSchema,
-    start_ms: z.number().int().min(0).default(0),
-    end_ms: z.number().int().min(1).optional(),
-    duration_ms: z.number().int().min(1).optional(),
-    output_format: z.enum(["mp3", "wav", "m4a"]).default("mp3"),
-    audio_bitrate_kbps: z.number().int().min(64).max(320).default(128)
-}).refine((value) => value.duration_ms != null || value.end_ms != null, {
-    message: "Either duration_ms or end_ms is required.",
-    path: ["duration_ms"]
-});
-const speechProviderSchema = z.enum(["openai", "gemini", "openrouter"]);
-const ttsPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    return {
-        ...payload,
-        text: payload.text ?? payload.input ?? payload.script,
-        instructions: payload.instructions ?? payload.style ?? payload.style_instructions ?? payload.voice_style
-    };
-}, z.object({
-    provider: speechProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    text: z.string().min(1).max(8000),
-    voice: z.string().min(1).max(120).optional(),
-    instructions: z.string().min(1).max(4000).optional(),
-    output_format: z.enum(["mp3", "wav"]).default("mp3"),
-    // Default TRUE: great ElevenLabs narration out of the box on the platform key,
-    // billed to the wallet. Set false to use your own ElevenLabs key or a BYOK
-    // openai/gemini/openrouter key instead. See voice options via /audio/voices.
-    use_wallet_credits: z.boolean().default(true)
-}).superRefine((value, ctx) => {
-    // Reject an explicit provider/voice contradiction at enqueue (400) instead
-    // of queueing a job that can only fail at the provider.
-    if (!value.provider || !value.voice)
-        return;
-    const mismatch = speechVoiceMismatch({ provider: value.provider, model: value.model, voice: value.voice });
-    if (mismatch) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["voice"], message: mismatch });
-    }
-}));
-const sttPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    return {
-        ...payload,
-        source_url: payload.source_url ??
-            payload.source_video_url ??
-            payload.source_audio_url ??
-            payload.source_media_url ??
-            payload.video_url ??
-            payload.audio_url ??
-            payload.url
-    };
-}, z.object({
-    provider: speechProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    source_url: mediaSourceUrlSchema,
-    media_type: z.enum(["auto", "video", "audio"]).default("auto"),
-    diarize: z.boolean().default(true),
-    // Word-level timings on each segment (animated captions). Real timestamps
-    // come from the openai path (whisper-1); other providers keep segment-level
-    // output and downstream callers estimate word windows.
-    word_timestamps: z.boolean().default(false),
-    language: z.string().min(2).max(16).optional(),
-    prompt: z.string().min(1).max(2000).optional(),
-    // Default TRUE: platform ElevenLabs Scribe (native diarization + real word
-    // timestamps), billed to the wallet. Set false to use your own ElevenLabs
-    // key or a BYOK gemini/openai/openrouter key.
-    use_wallet_credits: z.boolean().default(true)
-}));
-// Music generation (ElevenLabs). Prompt-based, or a hand-built composition plan.
-const musicPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    return {
-        ...payload,
-        prompt: payload.prompt ?? payload.text ?? payload.description,
-        music_length_ms: payload.music_length_ms ?? payload.length_ms ?? payload.duration_ms
-    };
-}, z.object({
-    prompt: z.string().min(1).max(2000).optional(),
-    // ElevenLabs music caps at 5 minutes per generation.
-    music_length_ms: z.number().int().min(3000).max(300000).default(30000),
-    // Optional ElevenLabs composition plan for granular section-by-section control.
-    composition_plan: z.record(z.string(), z.any()).optional(),
-    model: z.string().min(1).optional(),
-    output_format: z.string().min(1).optional(),
-    // Default TRUE: platform ElevenLabs key, billed to the wallet. Set false to
-    // use your own saved ElevenLabs key (no wallet charge).
-    use_wallet_credits: z.boolean().default(true)
-}).refine((value) => Boolean(value.prompt) || Boolean(value.composition_plan), {
-    message: "Provide either a prompt or a composition_plan.",
-    path: ["prompt"]
-}));
-// Animated captions from speech: STT with word-level timings, paged into
-// ready-to-apply cue layers. Either transcribe a source_url or page plain text.
-const captionsPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    return {
-        ...payload,
-        source_url: payload.source_url ??
-            payload.source_video_url ??
-            payload.source_audio_url ??
-            payload.source_media_url ??
-            payload.video_url ??
-            payload.audio_url ??
-            payload.url
-    };
-}, z.object({
-    provider: speechProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    source_url: mediaSourceUrlSchema.optional(),
-    media_type: z.enum(["auto", "video", "audio"]).default("auto"),
-    /** Skip STT entirely: page this script across the window instead. */
-    text: z.string().min(1).max(20_000).optional(),
-    language: z.string().min(2).max(16).optional(),
-    prompt: z.string().min(1).max(2000).optional(),
-    /** Named look: spotlight | karaoke | word-pop | stack-up | neon | bounce. */
-    style: z.string().min(1).max(32).optional(),
-    animation: z.enum(CAPTION_ANIMATIONS).optional(),
-    active_color: z.string().min(1).max(64).optional(),
-    highlight_color: z.string().min(1).max(64).optional(),
-    uppercase: z.boolean().optional(),
-    color: z.string().min(1).max(64).optional(),
-    background: z.string().min(1).max(64).optional(),
-    background_style: z.enum(["plain", "outline", "highlight-solid", "highlight-translucent"]).optional(),
-    font_family: z.string().min(1).max(64).optional(),
-    font_size: z.number().int().min(8).max(200).optional(),
-    max_words_per_cue: z.number().int().min(1).max(8).default(4),
-    /** Shift every cue by this many seconds (where the narration layer starts). */
-    offset_sec: z.number().min(0).max(3600).default(0),
-    /** Text mode window: where the paged script starts and how long it spans. */
-    window_start: z.number().min(0).max(3600).default(0),
-    window_duration: z.number().positive().max(3600).optional()
-}).refine((payload) => Boolean(payload.source_url || payload.text), {
-    message: "Provide source_url (audio/video to transcribe) or text (script to page)."
-}));
-// Regenerate speech in (approximately) the original speaker's voice: listen to
-// the source, transcribe + profile the voice, reword the script per the
-// caller's instruction (or take an exact new script), then TTS with the
-// closest preset voice + a style prompt matched to the speaker. OpenAI/Gemini
-// APIs cannot clone voice IDENTITY (preset voices only), so the result is an
-// honest approximation, never a clone — the output says so via voice_match.
-const speechRegeneratePayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    return {
-        ...payload,
-        source_url: payload.source_url ??
-            payload.source_video_url ??
-            payload.source_audio_url ??
-            payload.source_media_url ??
-            payload.video_url ??
-            payload.audio_url ??
-            payload.url,
-        text: payload.text ?? payload.script ?? payload.new_text,
-        rewrite_instruction: payload.rewrite_instruction ?? payload.instruction ?? payload.rewrite ?? payload.reword,
-        instructions: payload.instructions ?? payload.style ?? payload.style_instructions ?? payload.voice_style
-    };
-}, z.object({
-    provider: speechProviderSchema.optional(),
-    model: z.string().min(1).optional(),
-    source_url: mediaSourceUrlSchema,
-    media_type: z.enum(["auto", "video", "audio"]).default("auto"),
-    /** Exact new script to speak. Mutually optional with rewrite_instruction; one is required. */
-    text: z.string().min(1).max(8000).optional(),
-    /** How to reword the original transcript (e.g. "mention the summer sale instead of the discount code"). */
-    rewrite_instruction: z.string().min(1).max(4000).optional(),
-    /** Explicit preset override; skips the profiled voice recommendation. */
-    voice: z.string().min(1).max(120).optional(),
-    /** Extra voice-style guidance appended to the profiled style instructions. */
-    instructions: z.string().min(1).max(4000).optional(),
-    language: z.string().min(2).max(16).optional(),
-    output_format: z.enum(["mp3", "wav"]).default("mp3")
-}).refine((value) => Boolean(value.text || value.rewrite_instruction), {
-    message: "Provide text (the exact new script) or rewrite_instruction (how to reword the original transcript)."
-}).superRefine((value, ctx) => {
-    if (!value.provider || !value.voice)
-        return;
-    const mismatch = speechVoiceMismatch({ provider: value.provider, model: value.model, voice: value.voice });
-    if (mismatch) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["voice"], message: mismatch });
-    }
-}));
-const probeVideoPayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema
-});
-const removeVideoCaptionsPayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema
-});
-const probeAudioPayloadSchema = z.object({
-    source_audio_url: mediaSourceUrlSchema
-});
-const extractFramePayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema,
-    at_ms: z.number().int().min(0).default(0),
-    output_format: z.enum(["png", "jpeg"]).default("png")
-});
-const muteVideoPayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema
-});
-const replaceAudioPayloadSchema = z.object({
-    source_video_url: mediaSourceUrlSchema,
-    source_audio_url: mediaSourceUrlSchema,
-    audio_bitrate_kbps: z.number().int().min(64).max(320).default(128)
-});
-const concatVideoPayloadSchema = z.object({
-    source_video_urls: z.array(mediaSourceUrlSchema).min(1).max(32),
-    width: z.number().int().min(16).max(4096).optional(),
-    height: z.number().int().min(16).max(4096).optional(),
-    fit: mediaFitSchema.default("contain"),
-    background_color: z.string().min(1).max(64).default("#000000")
-});
-const concatAudioPayloadSchema = z.object({
-    source_audio_urls: z.array(mediaSourceUrlSchema).min(1).max(64),
-    output_format: z.enum(["mp3", "wav", "m4a"]).default("mp3"),
-    audio_bitrate_kbps: z.number().int().min(64).max(320).default(128)
-});
-const normalizeAudioPayloadSchema = z.object({
-    source_audio_url: mediaSourceUrlSchema,
-    output_format: z.enum(["mp3", "wav", "m4a"]).default("mp3"),
-    audio_bitrate_kbps: z.number().int().min(64).max(320).default(128),
-    sample_rate_hz: z.number().int().min(8_000).max(96_000).default(48_000)
-});
-const downloadVideoPayloadSchema = z.preprocess((raw) => {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
-        return raw;
-    const payload = raw;
-    return {
-        ...payload,
-        source_url: payload.source_url ?? payload.video_url ?? payload.url,
-        save_manifest: payload.save_manifest ?? payload.include_manifest ?? true
-    };
-}, z.object({
-    source_url: z.string().url(),
-    quality: z.enum(["best", "hd", "full_hd"]).default("best"),
-    save_manifest: z.boolean().default(true)
-}));
-// Ingest of an already-uploaded video file (Add Template → upload). The URL is
-// server-minted (our own storage), so no social-host restrictions apply.
-const ingestVideoPayloadSchema = z.object({
-    source_video_url: z.string().url(),
-    title: z.string().min(1).max(300).optional(),
-    file_name: z.string().min(1).max(300).optional(),
-    save_manifest: z.boolean().default(true)
-});
-const brainstormHooksPayloadSchema = z.preprocess(normalizeOfferDescriptionPayload, z.object({
-    offer_description: z.string().min(10).max(12_000),
-    count: brainstormCountSchema,
-    provider: textProviderSchema.optional(),
-    model: z.string().min(1).max(200).optional()
-}));
-const brainstormAwarenessStagesPayloadSchema = z.preprocess(normalizeOfferDescriptionPayload, z.object({
-    offer_description: z.string().min(10).max(12_000),
-    provider: textProviderSchema.optional(),
-    model: z.string().min(1).max(200).optional()
-}));
-const brainstormAnglesPayloadSchema = z.preprocess(normalizeAnglePayload, z.object({
-    offer_description: z.string().min(10).max(12_000),
-    problem_awareness: z.enum(["problem_unaware", "problem_aware"]),
-    solution_awareness: z.enum(["solution_unaware", "solution_aware"]),
-    count: brainstormCountSchema,
-    provider: textProviderSchema.optional(),
-    model: z.string().min(1).max(200).optional()
-}));
-const brainstormColdstartPayloadSchema = z.preprocess(normalizeColdstartPayload, z.object({
-    user_message: z.string().min(3).max(12_000),
-    count: z.number().int().min(6).max(30).default(12),
-    provider: textProviderSchema.optional(),
-    model: z.string().min(1).max(200).optional()
-}));
-const brainstormProductPlacementPayloadSchema = z.preprocess(normalizeProductPlacementPayload, z.object({
-    source_video_url: z.string().url(),
-    offer_description: z.string().min(10).max(12_000),
-    count: z.number().int().min(3).max(30).default(8),
-    provider: textProviderSchema.optional(),
-    model: z.string().min(1).max(200).optional()
-}));
-const brainstormHooksResultSchema = z.object({
-    hooks: z.array(z.object({
-        hook: z.string().min(1),
-        explanation: z.string().min(1)
-    })).min(1).max(50)
-});
-const brainstormAnglesResultSchema = z.object({
-    angles: z.array(z.object({
-        angle: z.string().min(1),
-        explanation: z.string().min(1)
-    })).min(1).max(50)
-});
-const brainstormColdstartResultSchema = z.object({
-    questions: z.array(z.object({
-        question: z.string().min(1),
-        why_it_matters: z.string().min(1)
-    })).min(6).max(30)
-});
-const brainstormProductPlacementResultSchema = z.object({
-    opportunities: z.array(z.object({
-        timestamp: z.string().min(1),
-        scene: z.string().min(1),
-        placement_type: z.string().min(1),
-        placement_idea: z.string().min(1),
-        why_it_works: z.string().min(1)
-    })).min(1).max(50)
-});
-const PRIMITIVE_IMAGE_GENERATE_ID = "primitive:image_generate";
-const PRIMITIVE_IMAGE_EDIT_ID = "primitive:image_edit";
-const PRIMITIVE_IMAGE_INPAINT_ID = "primitive:image_inpaint";
-const PRIMITIVE_IMAGE_RENDER_HTML_ID = "primitive:image_render_html";
-const PRIMITIVE_IMAGE_REMOVE_BACKGROUND_ID = "primitive:image_remove_background";
-const PRIMITIVE_IMAGE_REMOVE_BACKGROUND_GREENSCREEN_ID = "primitive:image_remove_background_greenscreen";
-const PRIMITIVE_MEDIA_OVERLAY_ID = "primitive:media_overlay";
-const PRIMITIVE_VIDEO_GENERATE_ID = "primitive:video_generate";
-const PRIMITIVE_VIDEO_RENDER_SLIDES_ID = "primitive:video_render_slides";
-const PRIMITIVE_VIDEO_NORMALIZE_ID = "primitive:video_normalize";
-const PRIMITIVE_VIDEO_DOWNLOAD_ID = "primitive:video_download";
-const PRIMITIVE_VIDEO_INGEST_ID = "primitive:video_ingest";
-const PRIMITIVE_VIDEO_TRIM_ID = "primitive:video_trim";
-const PRIMITIVE_VIDEO_REMOVE_CAPTIONS_ID = "primitive:video_remove_captions";
-const PRIMITIVE_VIDEO_EXTRACT_AUDIO_ID = "primitive:video_extract_audio";
-const PRIMITIVE_AUDIO_TRIM_ID = "primitive:audio_trim";
-const PRIMITIVE_VIDEO_PROBE_ID = "primitive:video_probe";
-const PRIMITIVE_AUDIO_PROBE_ID = "primitive:audio_probe";
-const PRIMITIVE_VIDEO_EXTRACT_FRAME_ID = "primitive:video_extract_frame";
-const PRIMITIVE_VIDEO_MUTE_ID = "primitive:video_mute";
-const PRIMITIVE_VIDEO_REPLACE_AUDIO_ID = "primitive:video_replace_audio";
-const PRIMITIVE_VIDEO_CONCAT_ID = "primitive:video_concat";
-const PRIMITIVE_AUDIO_CONCAT_ID = "primitive:audio_concat";
-const PRIMITIVE_AUDIO_NORMALIZE_ID = "primitive:audio_normalize";
-const PRIMITIVE_HYPERFRAMES_RENDER_ID = "primitive:hyperframes_render";
-const PRIMITIVE_BRAINSTORM_HOOKS_ID = "primitive:brainstorm_hooks";
-const PRIMITIVE_BRAINSTORM_AWARENESS_STAGES_ID = "primitive:brainstorm_awareness_stages";
-const PRIMITIVE_BRAINSTORM_ANGLES_ID = "primitive:brainstorm_angles";
-const PRIMITIVE_BRAINSTORM_COLDSTART_ID = "primitive:brainstorm_coldstart";
-const PRIMITIVE_BRAINSTORM_PRODUCT_PLACEMENT_ID = "primitive:brainstorm_product_placement";
-const PRIMITIVE_MEDIA_DEDUPE_ID = "primitive:media_dedupe";
-const PRIMITIVE_TTS_ID = "primitive:tts";
-const PRIMITIVE_STT_ID = "primitive:stt";
-const PRIMITIVE_MUSIC_ID = "primitive:music";
-const PRIMITIVE_CAPTIONS_ID = "primitive:captions";
-const PRIMITIVE_SPEECH_REGENERATE_ID = "primitive:speech_regenerate";
-// Gemini inline audio caps out around 20MB; at the 64kbps mono mp3 we extract,
-// that is roughly 40 minutes of speech.
-const MAX_TRANSCRIBE_AUDIO_BYTES = 20 * 1024 * 1024;
-// Keep job results comfortably under the DynamoDB item limit: transcripts
-// longer than this inline budget stay artifact-only (transcript.json).
-const MAX_INLINE_TRANSCRIPT_CHARS = 20_000;
-const primitiveMediaService = new PrimitiveMediaLambdaService();
-const hooksReferenceText = readPrimitiveAsset("SELLING_WITH_HOOKS.md");
-const awarenessReferenceText = readPrimitiveAsset("SELLING_AWARENESS_STAGES.md");
-const imageGeneratePrimitive = definePrimitive({
-    id: PRIMITIVE_IMAGE_GENERATE_ID,
-    kind: "image_generate",
-    operations: {
-        run: {
-            description: "Generate a new image and persist it as a reusable platform URL.",
-            inputSchema: generateImagePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = generateImagePayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Generating primitive image");
-            const provider = payload.provider ?? "openai";
-            const model = payload.model ?? defaultImageModelForProvider(provider);
-            const generated = await ctx.providers.generateImage({
-                provider,
-                model,
-                prompt: payload.prompt,
-                promptAttachments: payload.prompt_attachments,
-                aspectRatio: payload.aspect_ratio,
-                size: payload.size,
-                imageSize: payload.image_size
-            });
-            const normalized = await normalizePrimitiveImageOutput(generated.bytes, payload.output_format);
-            const stored = await storePrimitiveImage(ctx, {
-                key: `output.${extensionForOutputFormat(payload.output_format)}`,
-                bytes: normalized.bytes,
-                contentType: normalized.contentType,
-                metadata: {
-                    primitive: "image_generate",
-                    provider,
-                    model,
-                    prompt: payload.prompt,
-                    revisedPrompt: generated.revisedPrompt
-                }
-            });
-            ctx.logger.progress(1, "Primitive image generation complete");
-            return {
-                progress: 1,
-                output: buildImagePrimitiveOutput({
-                    fileUrl: stored.url,
-                    contentType: stored.contentType,
-                    revisedPrompt: generated.revisedPrompt,
-                    files: stored.url ? [stored.url] : []
-                })
-            };
-        }
-    }
-});
-const imageEditPrimitive = definePrimitive({
-    id: PRIMITIVE_IMAGE_EDIT_ID,
-    kind: "image_edit",
-    operations: {
-        run: {
-            description: "Edit an existing image into a new reusable platform URL.",
-            inputSchema: editImagePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = editImagePayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Editing primitive image");
-            const provider = payload.provider ?? "openai";
-            const model = payload.model ?? defaultImageModelForProvider(provider);
-            const edited = await ctx.providers.editImage({
-                provider,
-                model,
-                sourceImageUrl: payload.source_image_url,
-                instruction: payload.instruction,
-                referenceAttachments: payload.reference_attachments,
-                aspectRatio: payload.aspect_ratio,
-                size: payload.size,
-                imageSize: payload.image_size
-            });
-            const normalized = await normalizePrimitiveImageOutput(edited.bytes, payload.output_format);
-            const stored = await storePrimitiveImage(ctx, {
-                key: `output.${extensionForOutputFormat(payload.output_format)}`,
-                bytes: normalized.bytes,
-                contentType: normalized.contentType,
-                metadata: {
-                    primitive: "image_edit",
-                    provider,
-                    model,
-                    sourceImageUrl: payload.source_image_url,
-                    instruction: payload.instruction,
-                    revisedPrompt: edited.revisedPrompt
-                }
-            });
-            ctx.logger.progress(1, "Primitive image edit complete");
-            return {
-                progress: 1,
-                output: buildImagePrimitiveOutput({
-                    fileUrl: stored.url,
-                    contentType: stored.contentType,
-                    revisedPrompt: edited.revisedPrompt,
-                    derivedFromUrl: payload.source_image_url,
-                    files: stored.url ? [stored.url] : []
-                })
-            };
-        }
-    }
-});
-const imageInpaintPrimitive = definePrimitive({
-    id: PRIMITIVE_IMAGE_INPAINT_ID,
-    kind: "image_inpaint",
-    operations: {
-        run: {
-            description: "Edit a masked region of an existing image into a new reusable platform URL.",
-            inputSchema: inpaintImagePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = inpaintImagePayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Inpainting primitive image");
-            const provider = payload.provider ?? "openai";
-            const model = payload.model ?? defaultImageModelForProvider(provider);
-            const edited = await ctx.providers.inpaintImage({
-                provider,
-                model,
-                sourceImageUrl: payload.source_image_url,
-                maskUrl: payload.mask_url,
-                instruction: payload.instruction,
-                referenceAttachments: payload.reference_attachments,
-                aspectRatio: payload.aspect_ratio,
-                size: payload.size,
-                imageSize: payload.image_size
-            });
-            const normalized = await normalizePrimitiveImageOutput(edited.bytes, payload.output_format);
-            const stored = await storePrimitiveImage(ctx, {
-                key: `output.${extensionForOutputFormat(payload.output_format)}`,
-                bytes: normalized.bytes,
-                contentType: normalized.contentType,
-                metadata: {
-                    primitive: "image_inpaint",
-                    provider,
-                    model,
-                    sourceImageUrl: payload.source_image_url,
-                    maskUrl: payload.mask_url,
-                    instruction: payload.instruction,
-                    revisedPrompt: edited.revisedPrompt
-                }
-            });
-            ctx.logger.progress(1, "Primitive image inpaint complete");
-            return {
-                progress: 1,
-                output: buildImagePrimitiveOutput({
-                    fileUrl: stored.url,
-                    contentType: stored.contentType,
-                    revisedPrompt: edited.revisedPrompt,
-                    derivedFromUrl: payload.source_image_url,
-                    maskUrl: payload.mask_url,
-                    files: stored.url ? [stored.url] : []
-                })
-            };
-        }
-    }
-});
-const imageRenderHtmlPrimitive = definePrimitive({
-    id: PRIMITIVE_IMAGE_RENDER_HTML_ID,
-    kind: "image_render_html",
-    operations: {
-        run: {
-            description: "Render an HTML-driven still image into a reusable platform URL.",
-            inputSchema: renderHtmlImagePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = renderHtmlImagePayloadSchema.parse(input);
-            ctx.logger.progress(0.18, "Rendering primitive HTML image");
-            const rendered = await ctx.hyperframes.renderStill({
-                compositionHtml: buildHtmlImageCompositionHtml({
-                    compositionId: "primitive-html-image",
-                    width: payload.width,
-                    height: payload.height,
-                    backgroundColor: payload.background_color,
-                    html: payload.html,
-                    css: payload.css ?? ""
-                }),
-                compositionId: "primitive-html-image",
-                imageFormat: payload.output_format,
-                outputKey: `output.${extensionForOutputFormat(payload.output_format)}`
-            });
-            ctx.logger.progress(1, "Primitive HTML image render complete");
-            return {
-                progress: 1,
-                output: {
-                    files: rendered.outputUrl ? [rendered.outputUrl] : [],
-                    primary_file_url: rendered.outputUrl,
-                    image: {
-                        file_url: rendered.outputUrl,
-                        content_type: contentTypeForOutputFormat(payload.output_format),
-                        width: payload.width,
-                        height: payload.height
-                    },
-                    render: rendered
-                }
-            };
-        }
-    }
-});
-const imageRemoveBackgroundPrimitive = definePrimitive({
-    id: PRIMITIVE_IMAGE_REMOVE_BACKGROUND_ID,
-    kind: "image_remove_background",
-    operations: {
-        run: {
-            description: "Remove the background from a source image URL and store the transparent result as a reusable platform URL.",
-            inputSchema: removeBackgroundImagePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = removeBackgroundImagePayloadSchema.parse(input);
-            const sourceUrl = payload.source_image_url;
-            const sourceHost = safeUrlHost(sourceUrl);
-            const apiKey = (config.RAPIDAPI_KEY || "").trim();
-            if (!apiKey) {
-                throw new Error("RAPIDAPI_KEY is not configured.");
-            }
-            ctx.logger.progress(0.15, "Requesting remote background removal", {
-                sourceUrl,
-                sourceHost,
-                apiHost: config.RAPIDAPI_REMOVE_BACKGROUND_HOST
-            });
-            const apiResponse = await fetch(config.RAPIDAPI_REMOVE_BACKGROUND_URL, {
-                method: "POST",
-                headers: {
-                    "x-rapidapi-key": apiKey,
-                    "x-rapidapi-host": config.RAPIDAPI_REMOVE_BACKGROUND_HOST,
-                    "content-type": "application/x-www-form-urlencoded"
-                },
-                body: new URLSearchParams({ image_url: sourceUrl })
-            });
-            if (!apiResponse.ok) {
-                const details = await apiResponse.text().catch(() => "");
-                throw new Error(`Background removal failed with HTTP ${apiResponse.status}${details ? `: ${details.slice(0, 400)}` : ""}`);
-            }
-            const lookup = await apiResponse.json();
-            if (!lookup.url) {
-                throw new Error("Background removal returned no result URL.");
-            }
-            ctx.logger.progress(0.55, "Downloading background-removed image", {
-                remoteUrl: lookup.url
-            });
-            const remoteImage = await fetchRemoteBinary(lookup.url, "image/webp");
-            const normalized = await normalizePrimitiveImageOutput(remoteImage.bytes, payload.output_format);
-            const stored = await storePrimitiveImage(ctx, {
-                key: `output.${extensionForOutputFormat(payload.output_format)}`,
-                bytes: normalized.bytes,
-                contentType: normalized.contentType,
-                metadata: {
-                    primitive: "image_remove_background",
-                    source_image_url: sourceUrl,
-                    source_host: sourceHost,
-                    upstream_url: lookup.url,
-                    upstream_processing_time_seconds: lookup.processing_time ?? null
-                }
-            });
-            await ctx.billing.record({
-                type: "cpu_estimate",
-                costUsd: config.RAPIDAPI_REMOVE_BACKGROUND_COST_USD,
-                costCenterSlug: "rapidapi_remove_background",
-                idempotencyKey: `rapidapi_remove_background:${sourceUrl}`,
-                occurredAtMs: Date.now(),
-                metadata: {
-                    operation: "remove-background",
-                    source_image_url: sourceUrl,
-                    source_host: sourceHost,
-                    upstream_url: lookup.url,
-                    output_key: stored.key
-                }
-            });
-            ctx.logger.progress(1, "Background removal complete");
-            return {
-                progress: 1,
-                output: buildImagePrimitiveOutput({
-                    fileUrl: stored.url,
-                    contentType: stored.contentType,
-                    derivedFromUrl: sourceUrl,
-                    files: compactUrls([stored.url])
-                })
-            };
-        }
-    }
-});
-const imageRemoveBackgroundGreenscreenPrimitive = definePrimitive({
-    id: PRIMITIVE_IMAGE_REMOVE_BACKGROUND_GREENSCREEN_ID,
-    kind: "image_remove_background_greenscreen",
-    operations: {
-        run: {
-            description: "Cheap local chroma-key background removal. Drops a flat, solid key-color background (green screen by default; pass key_color for white/blue/any flat fill) to a transparent PNG/WebP cut-out using sharp — no third-party API, compute only. Ideal for images you generated on a controlled solid background; for arbitrary photos with a messy background use image_remove_background (RapidAPI matting) instead.",
-            inputSchema: greenscreenRemoveBackgroundPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = greenscreenRemoveBackgroundPayloadSchema.parse(input);
-            const sourceUrl = payload.source_image_url;
-            ctx.logger.progress(0.2, "Downloading source image for chroma key", { sourceUrl });
-            const source = await fetchRemoteBinary(sourceUrl, "image/png");
-            ctx.logger.progress(0.5, "Keying out background", { keyColor: payload.key_color });
-            const keyed = await chromaKeyRemoveBackground(source.bytes, {
-                keyColor: payload.key_color,
-                tolerance: payload.tolerance,
-                softness: payload.softness,
-                despill: payload.despill,
-                outputFormat: payload.output_format
-            });
-            const stored = await storePrimitiveImage(ctx, {
-                key: `output.${keyed.contentType === "image/webp" ? "webp" : "png"}`,
-                bytes: keyed.bytes,
-                contentType: keyed.contentType,
-                metadata: {
-                    primitive: "image_remove_background_greenscreen",
-                    source_image_url: sourceUrl,
-                    key_color: payload.key_color,
-                    tolerance: payload.tolerance,
-                    softness: payload.softness,
-                    despill: payload.despill,
-                    keyed_fraction: keyed.keyedFraction
-                }
-            });
-            await ctx.billing.record({
-                type: "cpu_estimate",
-                costUsd: config.GREENSCREEN_CHROMA_KEY_COST_USD,
-                costCenterSlug: "greenscreen_chroma_key",
-                occurredAtMs: Date.now(),
-                metadata: {
-                    operation: "remove-background-greenscreen",
-                    source_image_url: sourceUrl,
-                    key_color: payload.key_color,
-                    keyed_fraction: keyed.keyedFraction,
-                    output_key: stored.key
-                }
-            });
-            ctx.logger.progress(1, "Chroma-key background removal complete");
-            return {
-                progress: 1,
-                output: {
-                    ...buildImagePrimitiveOutput({
-                        fileUrl: stored.url,
-                        contentType: keyed.contentType,
-                        derivedFromUrl: sourceUrl,
-                        files: compactUrls([stored.url])
-                    }),
-                    key_color: payload.key_color,
-                    keyed_fraction: keyed.keyedFraction
-                }
-            };
-        }
-    }
-});
-const mediaOverlayPrimitive = definePrimitive({
-    id: PRIMITIVE_MEDIA_OVERLAY_ID,
-    kind: "media_overlay",
-    operations: {
-        run: {
-            description: "Create a transparent-background media overlay in ONE job: generate an AI image of the subject on a forced flat key-color background (using the caller's own BYOK image keys), then chroma-key that background out to a ready-to-composite transparent PNG/WebP. This is the go-to way to mint 'Vox-style' floating illustrations, props, icons, or cut-out characters to animate over a composition — prefer it over generate-then-manually-remove.",
-            inputSchema: mediaOverlayPayloadSchema,
-            workflow: "run",
-            providerHint: "openai"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = mediaOverlayPayloadSchema.parse(input);
-            const provider = payload.provider ?? "openai";
-            const model = payload.model ?? defaultImageModelForProvider(provider);
-            const keyRgb = parseKeyColor(payload.key_color);
-            const keyLabel = describeKeyColor(payload.key_color, keyRgb);
-            const augmentedPrompt = buildOverlayGenerationPrompt(payload.prompt, payload.key_color, keyLabel);
-            ctx.logger.progress(0.12, "Generating overlay subject on flat key-color background", { provider, model, keyColor: payload.key_color });
-            const generated = await ctx.providers.generateImage({
-                provider,
-                model,
-                prompt: augmentedPrompt,
-                promptAttachments: payload.prompt_attachments,
-                aspectRatio: payload.aspect_ratio,
-                imageSize: payload.image_size
-            });
-            // Keep the raw key-color frame as an artifact for debugging / re-keying at
-            // different tolerances without paying for a second generation.
-            const normalizedSource = await normalizePrimitiveImageOutput(generated.bytes, "png");
-            const sourceStored = await storePrimitiveImage(ctx, {
-                key: "source-greenscreen.png",
-                bytes: normalizedSource.bytes,
-                contentType: normalizedSource.contentType,
-                metadata: {
-                    primitive: "media_overlay",
-                    stage: "greenscreen_source",
-                    prompt: payload.prompt,
-                    key_color: payload.key_color,
-                    revised_prompt: generated.revisedPrompt
-                }
-            });
-            ctx.logger.progress(0.62, "Keying out background", { keyColor: payload.key_color });
-            const keyed = await chromaKeyRemoveBackground(generated.bytes, {
-                keyColor: payload.key_color,
-                tolerance: payload.tolerance,
-                softness: payload.softness,
-                despill: payload.despill,
-                outputFormat: payload.output_format
-            });
-            const stored = await storePrimitiveImage(ctx, {
-                key: `output.${keyed.contentType === "image/webp" ? "webp" : "png"}`,
-                bytes: keyed.bytes,
-                contentType: keyed.contentType,
-                metadata: {
-                    primitive: "media_overlay",
-                    stage: "transparent_overlay",
-                    prompt: payload.prompt,
-                    provider,
-                    model,
-                    key_color: payload.key_color,
-                    keyed_fraction: keyed.keyedFraction,
-                    revised_prompt: generated.revisedPrompt
-                }
-            });
-            await ctx.billing.record({
-                type: "cpu_estimate",
-                costUsd: config.MEDIA_OVERLAY_COST_USD,
-                costCenterSlug: "media_overlay",
-                occurredAtMs: Date.now(),
-                metadata: {
-                    operation: "create-media-overlay",
-                    prompt: payload.prompt,
-                    key_color: payload.key_color,
-                    keyed_fraction: keyed.keyedFraction,
-                    output_key: stored.key,
-                    greenscreen_source_key: sourceStored.key
-                }
-            });
-            ctx.logger.progress(1, "Media overlay ready");
-            return {
-                progress: 1,
-                output: {
-                    ...buildImagePrimitiveOutput({
-                        fileUrl: stored.url,
-                        contentType: keyed.contentType,
-                        revisedPrompt: generated.revisedPrompt,
-                        files: compactUrls([stored.url, sourceStored.url])
-                    }),
-                    greenscreen_source_url: sourceStored.url,
-                    key_color: payload.key_color,
-                    keyed_fraction: keyed.keyedFraction
-                }
-            };
-        }
-    }
-});
-const videoGeneratePrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_GENERATE_ID,
-    kind: "video_generate",
-    operations: {
-        run: {
-            description: "Generate a new AI video from a text prompt and optional reference images.",
-            inputSchema: generateVideoPayloadSchema,
-            workflow: "run",
-            providerHint: "openai"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = generateVideoPayloadSchema.parse(input);
-            const provider = payload.provider ?? "openai";
-            const model = payload.model ?? defaultVideoModelForProvider(provider);
-            ctx.logger.progress(0.08, "Submitting primitive AI video generation");
-            const generated = await ctx.providers.generateVideo({
-                provider,
-                model,
-                prompt: payload.prompt,
-                duration: payload.duration,
-                resolution: payload.resolution,
-                aspectRatio: payload.aspect_ratio,
-                size: payload.size,
-                generateAudio: payload.generate_audio,
-                frameImages: payload.frame_images.map((frame) => ({
-                    imageUrl: frame.image_url,
-                    frameType: frame.frame_type
-                })),
-                inputReferences: payload.input_references,
-                seed: payload.seed,
-                providerOptions: payload.provider_options
-            });
-            const stored = await storePrimitiveVideo(ctx, {
-                key: "output.mp4",
-                bytes: generated.bytes,
-                contentType: generated.contentType,
-                metadata: {
-                    primitive: "video_generate",
-                    provider,
-                    model,
-                    prompt: payload.prompt,
-                    providerJob: generated.providerJob
-                }
-            });
-            await recordPrimitiveProviderBilling(ctx, generated, "video_generate");
-            ctx.logger.progress(1, "Primitive AI video generation complete");
-            return {
-                progress: 1,
-                output: {
-                    files: stored.url ? [stored.url] : [],
-                    primary_file_url: stored.url,
-                    video: {
-                        file_url: stored.url,
-                        content_type: stored.contentType,
-                        provider,
-                        model
-                    },
-                    provider_job: generated.providerJob
-                }
-            };
-        }
-    }
-});
-const videoRenderSlidesPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_RENDER_SLIDES_ID,
-    kind: "video_render_slides",
-    operations: {
-        run: {
-            description: "Render image/video slides into a reusable MP4 from [{ media_url, duration_ms }].",
-            inputSchema: renderSlidesVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = renderSlidesVideoPayloadSchema.parse(input);
-            const durationMs = payload.slides.reduce((total, slide) => total + slide.duration_ms, 0);
-            ctx.logger.progress(0.18, "Rendering primitive media slideshow", {
-                executionMode: config.VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL ? "lambda" : "local_fallback"
-            });
-            const render = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_render_slides",
-                payload: {
-                    slides: payload.slides.map((slide) => ({
-                        media_url: slide.media_url,
-                        media_type: slide.media_type ?? inferMediaType(slide.media_url),
-                        duration_ms: slide.duration_ms,
-                        fit: slide.fit ?? payload.default_fit,
-                        background_color: slide.background_color ?? payload.background_color
-                    })),
-                    width: payload.width,
-                    height: payload.height,
-                    background_color: payload.background_color,
-                    default_fit: payload.default_fit
-                },
-                outputKey: "output.mp4"
-            });
-            ctx.logger.progress(1, "Primitive media slideshow render complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([
-                        ...payload.slides.map((slide) => slide.media_url),
-                        render.publicUrl
-                    ]),
-                    primary_file_url: render.publicUrl,
-                    video: {
-                        file_url: render.publicUrl,
-                        content_type: "video/mp4",
-                        width: payload.width,
-                        height: payload.height,
-                        duration_ms: durationMs,
-                        slide_count: payload.slides.length
-                    },
-                    render
-                }
-            };
-        }
-    }
-});
-const mediaDedupePrimitive = definePrimitive({
-    id: PRIMITIVE_MEDIA_DEDUPE_ID,
-    kind: "media_dedupe",
-    operations: {
-        run: {
-            description: "Apply dedupe transforms (zoom, tilt, rotate, playback speed, color filter, blur, tint, flip) to any source image or video URL for reuse across compositions.",
-            inputSchema: mediaDedupePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = mediaDedupePayloadSchema.parse(input);
-            const resolvedMediaType = payload.media_type ?? inferMediaType(payload.source_media_url);
-            const durationMs = payload.duration_ms ?? payload.fallback_duration_ms;
-            const dedupeComposition = (mediaType, durationSeconds) => buildMediaDedupeCompositionHtml({
-                compositionId: `primitive-media-dedupe-${mediaType}`,
-                mediaType,
-                sourceMediaUrl: payload.source_media_url,
-                width: payload.width,
-                height: payload.height,
-                durationSeconds,
-                effects: payload.effects,
-                tintColor: payload.tint_color,
-                tintOpacity: payload.tint_opacity,
-                objectFit: payload.object_fit,
-                objectPosition: payload.object_position,
-                backgroundColor: payload.background_color,
-                muted: payload.muted
-            });
-            ctx.logger.progress(0.2, "Rendering primitive media dedupe", {
-                mediaType: resolvedMediaType,
-                width: payload.width,
-                height: payload.height
-            });
-            if (resolvedMediaType === "image") {
-                const rendered = await ctx.hyperframes.renderStill({
-                    compositionHtml: dedupeComposition("image", 0.1),
-                    compositionId: "primitive-media-dedupe-image",
-                    imageFormat: payload.output_format,
-                    outputKey: `output.${extensionForOutputFormat(payload.output_format)}`
-                });
-                ctx.logger.progress(1, "Primitive media dedupe still complete");
-                return {
-                    progress: 1,
-                    output: {
-                        files: compactUrls([payload.source_media_url, rendered.outputUrl]),
-                        primary_file_url: rendered.outputUrl,
-                        image: {
-                            file_url: rendered.outputUrl,
-                            content_type: contentTypeForOutputFormat(payload.output_format),
-                            width: payload.width,
-                            height: payload.height,
-                            source_url: payload.source_media_url
-                        },
-                        render: rendered
-                    }
-                };
-            }
-            // Speed manifests as a shorter output clip: durationInFrames = (durationMs /
-            // speed) / 1000 * fps, matching the old media-dedupe.tsx frame count.
-            const speed = Math.max(0.1, payload.effects?.speed ?? DEDUPE_DEFAULT_EFFECTS.speed);
-            const outputDurationSeconds = Math.max(0.05, durationMs / speed / 1000);
-            const rendered = await ctx.hyperframes.render({
-                compositionHtml: dedupeComposition("video", outputDurationSeconds),
-                compositionId: "primitive-media-dedupe-video",
-                width: payload.width,
-                height: payload.height,
-                fps: 30
-            });
-            ctx.logger.progress(1, "Primitive media dedupe video complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_media_url, rendered.outputUrl]),
-                    primary_file_url: rendered.outputUrl,
-                    video: {
-                        file_url: rendered.outputUrl,
-                        content_type: "video/mp4",
-                        width: payload.width,
-                        height: payload.height,
-                        duration_ms: durationMs,
-                        source_url: payload.source_media_url
-                    },
-                    render: rendered
-                }
-            };
-        }
-    }
-});
-const videoNormalizePrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_NORMALIZE_ID,
-    kind: "video_normalize",
-    operations: {
-        run: {
-            description: "Normalize and compress a source MP4 into a render-friendly reusable platform MP4.",
-            inputSchema: normalizeVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = normalizeVideoPayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Normalizing source video", {
-                executionMode: config.VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL ? "lambda" : "local_fallback"
-            });
-            const normalized = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_normalize",
-                payload: {
-                    source_video_url: payload.source_video_url,
-                    max_width: payload.max_width,
-                    max_height: payload.max_height,
-                    crf: payload.crf,
-                    preset: payload.preset,
-                    max_video_bitrate_kbps: payload.max_video_bitrate_kbps,
-                    audio_bitrate_kbps: payload.audio_bitrate_kbps
-                },
-                outputKey: "normalized.mp4"
-            });
-            ctx.logger.progress(1, "Video normalization complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, normalized.publicUrl]),
-                    sourceVideoUrl: payload.source_video_url,
-                    normalizedVideoUrl: normalized.publicUrl,
-                    primary_file_url: normalized.publicUrl,
-                    video: {
-                        file_url: normalized.publicUrl,
-                        content_type: normalized.contentType,
-                        normalization: normalized.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const videoDownloadPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_DOWNLOAD_ID,
-    kind: "video_download",
-    operations: {
-        run: {
-            description: "Download a supported social/media post URL into a durable reusable platform MP4.",
-            inputSchema: downloadVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = downloadVideoPayloadSchema.parse(input);
-            const sourceUrl = payload.source_url;
-            const sourceHost = safeUrlHost(sourceUrl);
-            const apiKey = (config.RAPIDAPI_KEY || "").trim();
-            if (!apiKey) {
-                throw new Error("RAPIDAPI_KEY is not configured.");
-            }
-            ctx.logger.progress(0.12, "Requesting remote video download metadata", {
-                sourceUrl,
-                sourceHost,
-                apiHost: config.RAPIDAPI_VIDEO_DOWNLOAD_HOST
-            });
-            const downloadResponse = await fetch(config.RAPIDAPI_VIDEO_DOWNLOAD_URL, {
-                method: "POST",
-                headers: {
-                    "x-rapidapi-key": apiKey,
-                    "x-rapidapi-host": config.RAPIDAPI_VIDEO_DOWNLOAD_HOST,
-                    "content-type": "application/x-www-form-urlencoded"
-                },
-                body: new URLSearchParams({ url: sourceUrl })
-            });
-            if (!downloadResponse.ok) {
-                const details = await downloadResponse.text().catch(() => "");
-                throw new Error(`Video download lookup failed with HTTP ${downloadResponse.status}${details ? `: ${details.slice(0, 400)}` : ""}`);
-            }
-            const lookup = await downloadResponse.json();
-            const selectedMedia = selectDownloadedVideoMediaCandidate(lookup.medias ?? [], payload.quality);
-            if (!selectedMedia?.url) {
-                throw new Error("Video download lookup returned no playable MP4 media URL.");
-            }
-            ctx.logger.progress(0.45, "Downloading source video", {
-                selectedUrl: selectedMedia.url,
-                selectedQuality: selectedMedia.quality ?? null
-            });
-            const remoteVideo = await fetchRemoteBinary(selectedMedia.url, "video/mp4");
-            const contentType = normalizeVideoContentType(remoteVideo.contentType);
-            const extension = videoExtensionForContentType(contentType);
-            const storedVideo = await storePrimitiveVideo(ctx, {
-                key: `source-video.${extension}`,
-                bytes: remoteVideo.bytes,
-                contentType,
-                metadata: {
-                    primitive: "video_download",
-                    operation: "download-video",
-                    source_url: sourceUrl,
-                    source_host: sourceHost,
-                    selected_media_url: selectedMedia.url,
-                    selected_quality: selectedMedia.quality ?? null,
-                    upstream_source: lookup.source ?? null
-                }
-            });
-            // Re-host a DURABLE poster so the frontend never depends on the ephemeral
-            // third-party `lookup.thumbnail` URL. Prefer extracting a frame from the
-            // MP4 we just stored (works even when the provider gives no thumbnail);
-            // fall back to re-hosting the provider thumbnail bytes. Best-effort.
-            let durableThumbnailUrl = null;
-            ctx.logger.progress(0.7, "Extracting thumbnail frame");
-            try {
-                const frame = await executePrimitiveMediaOperation(ctx, {
-                    operation: "video_extract_frame",
-                    payload: { source_video_url: storedVideo.url, at_ms: 1000, output_format: "jpeg" },
-                    outputKey: "thumbnail.jpg"
-                });
-                durableThumbnailUrl = frame.publicUrl;
-            }
-            catch (error) {
-                ctx.logger.progress(0.75, "Thumbnail frame extraction skipped", {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-            if (!durableThumbnailUrl && lookup.thumbnail) {
-                try {
-                    const remoteThumb = await fetchRemoteBinary(lookup.thumbnail, "image/jpeg");
-                    const thumbContentType = remoteThumb.contentType.startsWith("image/") ? remoteThumb.contentType : "image/jpeg";
-                    const storedThumb = await storePrimitiveImage(ctx, {
-                        key: "thumbnail.jpg",
-                        bytes: remoteThumb.bytes,
-                        contentType: thumbContentType,
-                        metadata: {
-                            primitive: "video_download",
-                            operation: "download-video",
-                            source_url: sourceUrl,
-                            rehosted_from: lookup.thumbnail
-                        }
-                    });
-                    durableThumbnailUrl = storedThumb.url;
-                }
-                catch (error) {
-                    ctx.logger.progress(0.78, "Thumbnail re-host skipped", {
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            const manifest = {
-                primitive: "video_download",
-                operation: "download-video",
-                sourceUrl,
-                sourceHost,
-                title: lookup.title ?? null,
-                // Raw ephemeral third-party thumbnail (kept for provenance) plus the
-                // durable re-hosted poster the finalizer/frontend should actually use.
-                thumbnail: durableThumbnailUrl ?? lookup.thumbnail ?? null,
-                rawThumbnail: lookup.thumbnail ?? null,
-                duration: lookup.duration ?? null,
-                source: lookup.source ?? null,
-                selectedMedia: {
-                    url: selectedMedia.url,
-                    quality: selectedMedia.quality ?? null,
-                    extension: selectedMedia.extension ?? extension,
-                    audioAvailable: selectedMedia.audioAvailable ?? null,
-                    videoAvailable: selectedMedia.videoAvailable ?? null
-                },
-                videoUrl: storedVideo.url
-            };
-            const manifestArtifact = payload.save_manifest
-                ? await ctx.storage.putJson("manifest.json", manifest)
-                : null;
-            await ctx.billing.record({
-                type: "cpu_estimate",
-                costUsd: config.RAPIDAPI_VIDEO_DOWNLOAD_BASE_COST_USD,
-                costCenterSlug: "rapidapi_video_download",
-                idempotencyKey: `rapidapi_video_download:${sourceUrl}`,
-                occurredAtMs: Date.now(),
-                metadata: {
-                    operation: "download-video",
-                    source_url: sourceUrl,
-                    source_host: sourceHost,
-                    selected_quality: selectedMedia.quality ?? null
-                }
-            });
-            await ctx.billing.record({
-                type: "cpu_estimate",
-                costUsd: config.RAPIDAPI_VIDEO_DOWNLOAD_LAMBDA_COST_USD,
-                costCenterSlug: "video_download_lambda",
-                idempotencyKey: `video_download_lambda:${sourceUrl}:${storedVideo.key}`,
-                occurredAtMs: Date.now(),
-                metadata: {
-                    operation: "download-video",
-                    source_url: sourceUrl,
-                    source_host: sourceHost,
-                    output_key: storedVideo.key,
-                    content_type: contentType,
-                    bytes: remoteVideo.bytes.length
-                }
-            });
-            ctx.logger.progress(1, "Video download complete", {
-                videoUrl: storedVideo.url,
-                sourceHost,
-                thumbnailUrl: durableThumbnailUrl
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([storedVideo.url, durableThumbnailUrl, manifestArtifact?.url]),
-                    sourceUrl,
-                    sourceHost,
-                    videoUrl: storedVideo.url,
-                    sourceVideoUrl: storedVideo.url,
-                    primary_file_url: storedVideo.url,
-                    title: lookup.title ?? null,
-                    // Durable re-hosted poster (falls back to the raw provider thumbnail).
-                    thumbnailUrl: durableThumbnailUrl ?? lookup.thumbnail ?? null,
-                    thumbnail: durableThumbnailUrl ?? lookup.thumbnail ?? null,
-                    duration: lookup.duration ?? null,
-                    selectedMediaUrl: selectedMedia.url,
-                    manifest: manifestArtifact
-                }
-            };
-        }
-    }
-});
-// Upload-based sibling of video_download: the source video already sits in our
-// storage (uploaded via the Add Template flow), so there is no social lookup —
-// just mirror it into a durable job artifact, probe duration, and grab a
-// thumbnail frame. Output shape matches video_download so the inspiration
-// finalizer treats both identically.
-const videoIngestPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_INGEST_ID,
-    kind: "video_ingest",
-    operations: {
-        run: {
-            description: "Ingest an uploaded source video file into a durable reusable platform MP4 with probed metadata and a thumbnail.",
-            inputSchema: ingestVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = ingestVideoPayloadSchema.parse(input);
-            const sourceUrl = payload.source_video_url;
-            const sourceHost = safeUrlHost(sourceUrl);
-            ctx.logger.progress(0.12, "Fetching uploaded source video", { sourceUrl, sourceHost });
-            const remoteVideo = await fetchRemoteBinary(sourceUrl, "video/mp4");
-            const contentType = normalizeVideoContentType(remoteVideo.contentType);
-            const extension = videoExtensionForContentType(contentType);
-            const storedVideo = await storePrimitiveVideo(ctx, {
-                key: `source-video.${extension}`,
-                bytes: remoteVideo.bytes,
-                contentType,
-                metadata: {
-                    primitive: "video_ingest",
-                    operation: "ingest-video",
-                    source_url: sourceUrl,
-                    source_host: sourceHost,
-                    file_name: payload.file_name ?? null
-                }
-            });
-            // Best-effort enrichment: a probe past the duration cap or a failed
-            // thumbnail must not sink the ingest — the card still finalizes and the
-            // template can decompose later.
-            let durationSeconds = null;
-            ctx.logger.progress(0.55, "Probing uploaded video metadata");
-            try {
-                const probed = await executePrimitiveMediaOperation(ctx, {
-                    operation: "video_probe",
-                    payload: { source_video_url: storedVideo.url },
-                    outputKey: "probe.json"
-                });
-                const probedDuration = Number(probed.metadata?.durationSeconds);
-                durationSeconds = Number.isFinite(probedDuration) && probedDuration > 0 ? probedDuration : null;
-            }
-            catch (error) {
-                ctx.logger.progress(0.6, "Video probe skipped", {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-            let thumbnailUrl = null;
-            ctx.logger.progress(0.7, "Extracting thumbnail frame");
-            try {
-                const frame = await executePrimitiveMediaOperation(ctx, {
-                    operation: "video_extract_frame",
-                    payload: { source_video_url: storedVideo.url, at_ms: 0, output_format: "jpeg" },
-                    outputKey: "thumbnail.jpg"
-                });
-                thumbnailUrl = frame.publicUrl;
-            }
-            catch (error) {
-                ctx.logger.progress(0.75, "Thumbnail extraction skipped", {
-                    error: error instanceof Error ? error.message : String(error)
-                });
-            }
-            const manifest = {
-                primitive: "video_ingest",
-                operation: "ingest-video",
-                sourceUrl,
-                sourceHost,
-                // Caller-chosen title only — never the file name. Untitled ingests
-                // finalize with title null so the template displays as its id.
-                title: payload.title ?? null,
-                thumbnail: thumbnailUrl,
-                duration: durationSeconds,
-                source: "upload",
-                videoUrl: storedVideo.url
-            };
-            const manifestArtifact = payload.save_manifest
-                ? await ctx.storage.putJson("manifest.json", manifest)
-                : null;
-            await ctx.billing.record({
-                type: "cpu_estimate",
-                costUsd: config.RAPIDAPI_VIDEO_DOWNLOAD_LAMBDA_COST_USD,
-                costCenterSlug: "video_ingest_lambda",
-                idempotencyKey: `video_ingest_lambda:${sourceUrl}:${storedVideo.key}`,
-                occurredAtMs: Date.now(),
-                metadata: {
-                    operation: "ingest-video",
-                    source_url: sourceUrl,
-                    source_host: sourceHost,
-                    output_key: storedVideo.key,
-                    content_type: contentType,
-                    bytes: remoteVideo.bytes.length
-                }
-            });
-            ctx.logger.progress(1, "Video ingest complete", {
-                videoUrl: storedVideo.url,
-                durationSeconds,
-                thumbnailUrl
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([storedVideo.url, thumbnailUrl, manifestArtifact?.url]),
-                    sourceUrl,
-                    sourceHost,
-                    videoUrl: storedVideo.url,
-                    sourceVideoUrl: storedVideo.url,
-                    primary_file_url: storedVideo.url,
-                    title: manifest.title,
-                    thumbnail: thumbnailUrl,
-                    duration: durationSeconds,
-                    // Manifest CONTENT (not the artifact record) so the inspiration
-                    // finalizer can read thumbnail/title/duration directly.
-                    manifest
-                }
-            };
-        }
-    }
-});
-const videoTrimPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_TRIM_ID,
-    kind: "video_trim",
-    operations: {
-        run: {
-            description: "Trim a source video into a reusable platform MP4.",
-            inputSchema: trimVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = trimVideoPayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Trimming source video", {
-                executionMode: config.VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL ? "lambda" : "local_fallback"
-            });
-            const trimmed = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_trim",
-                payload,
-                outputKey: "trimmed.mp4"
-            });
-            ctx.logger.progress(1, "Video trim complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, trimmed.publicUrl]),
-                    sourceVideoUrl: payload.source_video_url,
-                    trimmedVideoUrl: trimmed.publicUrl,
-                    primary_file_url: trimmed.publicUrl,
-                    video: {
-                        file_url: trimmed.publicUrl,
-                        content_type: trimmed.contentType,
-                        trim: trimmed.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-// GhostCut task polling budget. The job runner lambda has a 15-minute
-// timeout; probe + submit + mirror take up the rest. GhostCut usually clears
-// a sub-3-minute clip in a few minutes.
-const REMOVE_CAPTIONS_POLL_TIMEOUT_MS = 12 * 60 * 1000;
-const REMOVE_CAPTIONS_POLL_INTERVAL_MS = 5000;
-// Removes burned-in captions/subtitles/on-screen text from a source video via
-// the GhostCut inpainting service — the same plumbing auto-decompose uses
-// through src/services/ghostcut.ts. Unlike the fork-scoped
-// /remove-video-captions(-poll) composition routes, where the CLIENT drives
-// completion to keep per-request lambda time bounded, this primitive runs
-// inside the job runner and polls GhostCut to completion itself.
-const videoRemoveCaptionsPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_REMOVE_CAPTIONS_ID,
-    kind: "video_remove_captions",
-    operations: {
-        run: {
-            description: "Remove burned-in captions/subtitles/on-screen text from a source video into a reusable caption-free platform MP4.",
-            inputSchema: removeVideoCaptionsPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = removeVideoCaptionsPayloadSchema.parse(input);
-            if (!isGhostcutConfigured()) {
-                throw new Error("Caption removal is unavailable: GHOSTCUT_KEY/GHOSTCUT_SECRET are not configured on this deployment.");
-            }
-            // Probe first: confirms the source actually has a video stream and
-            // captures the duration that prices the GhostCut task (per-30s chunks).
-            ctx.logger.progress(0.05, "Probing source video");
-            const probed = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_probe",
-                payload: { source_video_url: payload.source_video_url },
-                outputKey: "probe.json"
-            });
-            const probeMetadata = (probed.metadata ?? {});
-            if (probeMetadata.hasVideo === false) {
-                throw new Error("source_video_url has no video stream — caption removal only works on videos.");
-            }
-            const probedDurationSeconds = Number(probeMetadata.durationSeconds ?? 0);
-            const durationSeconds = Number.isFinite(probedDurationSeconds) && probedDurationSeconds > 0 ? probedDurationSeconds : 30;
-            // GhostCut is a per-FINISHED-CLIP tool, never a long-form pass. Clip
-            // hunting handles "no captions" as a scene-selection filter (avoid_text);
-            // after the hunt, apply caption removal to individual finished clips.
-            if (config.GHOSTCUT_MAX_DURATION_SEC > 0 && durationSeconds > config.GHOSTCUT_MAX_DURATION_SEC) {
-                throw new Error(`Caption removal is limited to videos up to ${Math.round(config.GHOSTCUT_MAX_DURATION_SEC / 60)} minutes (this source is ${Math.round(durationSeconds / 60)} min). ` +
-                    `For long-form video, hunt clips first (POST /clips/scan with avoid_text/no-captions guidance selects text-free scenes), then remove captions from the finished clips you keep.`);
-            }
-            const cost = estimateGhostcutCostUsd(durationSeconds);
-            ctx.logger.progress(0.12, "Submitting caption-removal task", {
-                durationSeconds: Number(durationSeconds.toFixed(3)),
-                estimatedChunks: cost.chunks,
-                estimatedUsd: cost.usd
-            });
-            const submission = await submitSubtitleRemoval(payload.source_video_url);
-            const startedAtMs = Date.now();
-            let cleanedVideoUrl = null;
-            while (cleanedVideoUrl === null) {
-                if (Date.now() - startedAtMs > REMOVE_CAPTIONS_POLL_TIMEOUT_MS) {
-                    throw new Error(`GhostCut task ${submission.taskId} did not finish within ${Math.round(REMOVE_CAPTIONS_POLL_TIMEOUT_MS / 60000)} minutes.`);
-                }
-                const status = await pollGhostcutStatus(submission.taskId);
-                if (status.state === "failed") {
-                    throw new Error(`GhostCut task ${submission.taskId} failed: ${status.reason}`);
-                }
-                if (status.state === "done") {
-                    cleanedVideoUrl = status.videoUrl;
-                    break;
-                }
-                const upstreamProgress = Math.max(0, Math.min(100, status.progress));
-                ctx.logger.progress(0.15 + (upstreamProgress / 100) * 0.65, "Removing burned-in captions", {
-                    taskId: submission.taskId,
-                    upstreamProgress
-                });
-                await new Promise((resolve) => setTimeout(resolve, REMOVE_CAPTIONS_POLL_INTERVAL_MS));
-            }
-            // GhostCut hosts results on a short-lived third-party CDN — mirror the
-            // cleaned MP4 into platform storage so the output URL is durable.
-            ctx.logger.progress(0.85, "Mirroring caption-free video to platform storage");
-            const remoteVideo = await fetchRemoteBinary(cleanedVideoUrl, "video/mp4");
-            const stored = await storePrimitiveVideo(ctx, {
-                key: "captions-removed.mp4",
-                bytes: remoteVideo.bytes,
-                contentType: "video/mp4",
-                metadata: {
-                    primitive: "video_remove_captions",
-                    operation: "remove-video-captions",
-                    source_video_url: payload.source_video_url,
-                    ghostcut_task_id: submission.taskId
-                }
-            });
-            await ctx.billing.record({
-                type: "cpu_estimate",
-                costUsd: cost.usd,
-                costCenterSlug: "ghostcut_subtitle_removal",
-                idempotencyKey: `ghostcut_subtitle_removal:${submission.taskId}`,
-                occurredAtMs: Date.now(),
-                metadata: {
-                    operation: "remove-video-captions",
-                    source_video_url: payload.source_video_url,
-                    duration_seconds: Number(durationSeconds.toFixed(3)),
-                    chunk_count: cost.chunks,
-                    usd_per_chunk: cost.usdPerChunk,
-                    chunk_seconds: 30,
-                    task_id: submission.taskId
-                }
-            });
-            ctx.logger.progress(1, "Caption removal complete", { videoUrl: stored.url });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, stored.url]),
-                    sourceVideoUrl: payload.source_video_url,
-                    captionsRemovedVideoUrl: stored.url,
-                    primary_file_url: stored.url,
-                    video: {
-                        file_url: stored.url,
-                        content_type: stored.contentType,
-                        duration_seconds: Number(durationSeconds.toFixed(3)),
-                        ghostcut_task_id: submission.taskId
-                    }
-                }
-            };
-        }
-    }
-});
-const videoExtractAudioPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_EXTRACT_AUDIO_ID,
-    kind: "video_extract_audio",
-    operations: {
-        run: {
-            description: "Extract audio from a source video into a reusable platform audio file.",
-            inputSchema: extractAudioPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = extractAudioPayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Extracting audio from source video", {
-                executionMode: config.VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL ? "lambda" : "local_fallback"
-            });
-            const extracted = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_extract_audio",
-                payload,
-                outputKey: `audio.${payload.output_format}`
-            });
-            ctx.logger.progress(1, "Video audio extraction complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, extracted.publicUrl]),
-                    sourceVideoUrl: payload.source_video_url,
-                    audioUrl: extracted.publicUrl,
-                    primary_file_url: extracted.publicUrl,
-                    audio: {
-                        file_url: extracted.publicUrl,
-                        content_type: extracted.contentType,
-                        extraction: extracted.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const audioTrimPrimitive = definePrimitive({
-    id: PRIMITIVE_AUDIO_TRIM_ID,
-    kind: "audio_trim",
-    operations: {
-        run: {
-            description: "Trim a source audio file into a reusable platform audio file.",
-            inputSchema: trimAudioPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = trimAudioPayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Trimming source audio", {
-                executionMode: config.VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL ? "lambda" : "local_fallback"
-            });
-            const trimmed = await executePrimitiveMediaOperation(ctx, {
-                operation: "audio_trim",
-                payload,
-                outputKey: `trimmed.${payload.output_format}`
-            });
-            ctx.logger.progress(1, "Audio trim complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_audio_url, trimmed.publicUrl]),
-                    sourceAudioUrl: payload.source_audio_url,
-                    trimmedAudioUrl: trimmed.publicUrl,
-                    primary_file_url: trimmed.publicUrl,
-                    audio: {
-                        file_url: trimmed.publicUrl,
-                        content_type: trimmed.contentType,
-                        trim: trimmed.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const ttsPrimitive = definePrimitive({
-    id: PRIMITIVE_TTS_ID,
-    kind: "tts",
-    operations: {
-        run: {
-            description: "Generate spoken narration audio from text (TTS) with a promptable voice style, persisted as a reusable platform audio URL.",
-            inputSchema: ttsPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = ttsPayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Generating speech audio");
-            // A bare voice preset implies its provider ("Puck" → gemini) — blindly
-            // defaulting to openai would guarantee a cross-family voice failure.
-            const provider = payload.provider ?? inferSpeechProviderForVoice(payload.voice) ?? "openai";
-            const model = payload.model ?? defaultSpeechModelFor("tts", provider) ?? "";
-            const generated = await ctx.providers.generateSpeech({
-                provider,
-                model,
-                text: payload.text,
-                voice: payload.voice,
-                instructions: payload.instructions,
-                responseFormat: payload.output_format,
-                useWalletCredits: payload.use_wallet_credits
-            });
-            // Route may have resolved to a different provider (e.g. platform ElevenLabs
-            // when use_wallet_credits is on); report what actually ran.
-            const effectiveProvider = generated.effectiveProvider;
-            const effectiveModel = generated.effectiveModel;
-            if (generated.billing) {
-                await ctx.billing.record({
-                    type: "ai_generation",
-                    costUsd: generated.billing.costUsd,
-                    costCenterSlug: generated.billing.costCenterSlug,
-                    metadata: { ...generated.billing.metadata, primitive: "tts", voice: payload.voice ?? null }
-                });
-            }
-            // Gemini/ElevenLabs TTS may answer in wav regardless of the requested
-            // format; name the artifact after what actually came back.
-            const extension = generated.contentType.includes("wav") ? "wav" : "mp3";
-            const stored = await ctx.storage.putBuffer(`speech.${extension}`, generated.bytes, {
-                contentType: generated.contentType,
-                kind: "audio",
-                metadata: {
-                    primitive: "tts",
-                    provider: effectiveProvider,
-                    model: effectiveModel,
-                    voice: payload.voice ?? null,
-                    styleInstructions: payload.instructions ?? null,
-                    wallet_billed: Boolean(generated.billing)
-                }
-            });
-            ctx.logger.progress(1, "Speech generation complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([stored.url]),
-                    primary_file_url: stored.url,
-                    audioUrl: stored.url,
-                    audio: {
-                        file_url: stored.url,
-                        content_type: generated.contentType,
-                        provider: effectiveProvider,
-                        model: effectiveModel,
-                        voice: payload.voice ?? null,
-                        style_instructions: payload.instructions ?? null,
-                        text_length: payload.text.length,
-                        wallet_billed: Boolean(generated.billing)
-                    }
-                }
-            };
-        }
-    }
-});
-const musicPrimitive = definePrimitive({
-    id: PRIMITIVE_MUSIC_ID,
-    kind: "music",
-    operations: {
-        run: {
-            description: "Generate music (instrumental or with lyrics) from a prompt or a composition plan via ElevenLabs, persisted as a reusable platform audio URL.",
-            inputSchema: musicPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = musicPayloadSchema.parse(input);
-            ctx.logger.progress(0.12, "Composing music");
-            const generated = await ctx.providers.generateMusic({
-                prompt: payload.prompt,
-                musicLengthMs: payload.music_length_ms,
-                compositionPlan: payload.composition_plan,
-                model: payload.model,
-                outputFormat: payload.output_format,
-                useWalletCredits: payload.use_wallet_credits
-            });
-            if (generated.billing) {
-                await ctx.billing.record({
-                    type: "ai_generation",
-                    costUsd: generated.billing.costUsd,
-                    costCenterSlug: generated.billing.costCenterSlug,
-                    metadata: { ...generated.billing.metadata, primitive: "music", prompt: payload.prompt ?? null }
-                });
-            }
-            const stored = await ctx.storage.putBuffer("music.mp3", generated.bytes, {
-                contentType: generated.contentType,
-                kind: "audio",
-                metadata: {
-                    primitive: "music",
-                    provider: "elevenlabs",
-                    music_length_ms: generated.musicLengthMs,
-                    wallet_billed: Boolean(generated.billing)
-                }
-            });
-            ctx.logger.progress(1, "Music generation complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([stored.url]),
-                    primary_file_url: stored.url,
-                    audioUrl: stored.url,
-                    audio: {
-                        file_url: stored.url,
-                        content_type: generated.contentType,
-                        provider: "elevenlabs",
-                        music_length_ms: generated.musicLengthMs,
-                        prompt: payload.prompt ?? null,
-                        wallet_billed: Boolean(generated.billing)
-                    }
-                }
-            };
-        }
-    }
-});
-// Shared source→speech-ready-audio loader for the STT-family primitives.
-// Plain audio URLs pass through; videos (and unknown containers) go through
-// the ffmpeg seam, which demuxes and normalizes into a small mono mp3 the
-// speech providers accept.
-async function loadSpeechAudioForPrimitive(ctx, payload) {
-    const sourceKind = payload.media_type === "auto" ? inferSpeechSourceKind(payload.source_url) : payload.media_type;
-    let audioBytes;
-    let audioContentType;
-    let audioUrl;
-    let extractionMetadata = null;
-    if (sourceKind === "audio") {
-        ctx.logger.progress(0.1, "Fetching source audio");
-        const response = await fetch(payload.source_url);
-        if (!response.ok) {
-            throw new Error(`Could not fetch source audio (${response.status}).`);
-        }
-        audioBytes = new Uint8Array(await response.arrayBuffer());
-        audioContentType = response.headers.get("content-type")?.split(";")[0]?.trim() || "audio/mpeg";
-        audioUrl = payload.source_url;
-    }
-    else {
-        ctx.logger.progress(0.1, "Extracting audio track from source", {
-            executionMode: config.VIDFARM_PRIMITIVE_MEDIA_LAMBDA_URL ? "lambda" : "local_fallback"
-        });
-        const extracted = await executePrimitiveMediaOperation(ctx, {
-            operation: "video_extract_audio",
-            payload: {
-                source_video_url: payload.source_url,
-                output_format: "mp3",
-                audio_bitrate_kbps: 64
-            },
-            outputKey: "source-audio.mp3"
-        });
-        if (!extracted.publicUrl) {
-            throw new Error("Audio extraction produced no readable audio URL.");
-        }
-        const response = await fetch(extracted.publicUrl);
-        if (!response.ok) {
-            throw new Error(`Could not read extracted audio (${response.status}).`);
-        }
-        audioBytes = new Uint8Array(await response.arrayBuffer());
-        audioContentType = extracted.contentType || "audio/mpeg";
-        audioUrl = extracted.publicUrl;
-        extractionMetadata = extracted.metadata ?? null;
-    }
-    if (audioBytes.byteLength > MAX_TRANSCRIBE_AUDIO_BYTES) {
-        const sizeMb = Math.round(audioBytes.byteLength / (1024 * 1024));
-        const maxMb = Math.round(MAX_TRANSCRIBE_AUDIO_BYTES / (1024 * 1024));
-        throw new Error(`Audio is too large to transcribe (${sizeMb}MB > ${maxMb}MB, roughly 40 minutes of speech). Trim the source with /videos/trim or /audio/trim and transcribe in parts.`);
-    }
-    return { audioBytes, audioContentType, audioUrl, extractionMetadata };
-}
-const sttPrimitive = definePrimitive({
-    id: PRIMITIVE_STT_ID,
-    kind: "stt",
-    operations: {
-        run: {
-            description: "Transcribe speech from a video or audio URL (STT) into a simple subtitle transcript plus speaker-attributed multi-narration segments.",
-            inputSchema: sttPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = sttPayloadSchema.parse(input);
-            const { audioBytes, audioContentType, extractionMetadata } = await loadSpeechAudioForPrimitive(ctx, payload);
-            ctx.logger.progress(0.45, "Transcribing speech");
-            const requestedProvider = payload.provider ?? (payload.word_timestamps ? "openai" : "gemini");
-            const requestedModel = payload.model ?? defaultSpeechModelFor("stt", requestedProvider) ?? "";
-            const transcription = await ctx.providers.transcribeSpeech({
-                provider: requestedProvider,
-                model: requestedModel,
-                audio: audioBytes,
-                contentType: audioContentType,
-                prompt: payload.prompt,
-                language: payload.language,
-                diarize: payload.diarize,
-                wordTimestamps: payload.word_timestamps,
-                useWalletCredits: payload.use_wallet_credits
-            });
-            const provider = transcription.effectiveProvider;
-            const model = transcription.effectiveModel;
-            if (transcription.billing) {
-                await ctx.billing.record({
-                    type: "ai_generation",
-                    costUsd: transcription.billing.costUsd,
-                    costCenterSlug: transcription.billing.costCenterSlug,
-                    metadata: { ...transcription.billing.metadata, primitive: "stt", source_url: payload.source_url }
-                });
-            }
-            ctx.logger.progress(0.85, "Storing transcript artifacts");
-            const speakers = [...new Set(transcription.segments.map((segment) => segment.speaker))];
-            const srt = buildSrtFromSegments(transcription.segments);
-            const storedText = await ctx.storage.putText("transcript.txt", transcription.text || "");
-            const storedSrt = srt ? await ctx.storage.putText("transcript.srt", srt, "application/x-subrip; charset=utf-8") : null;
-            const storedJson = await ctx.storage.putJson("transcript.json", {
-                source_url: payload.source_url,
-                provider,
-                model,
-                language: transcription.language,
-                diarization: transcription.diarization,
-                text: transcription.text,
-                speakers,
-                segments: transcription.segments,
-                ...(extractionMetadata ? { extraction: extractionMetadata } : {})
-            });
-            const inlineOk = (transcription.text?.length ?? 0) <= MAX_INLINE_TRANSCRIPT_CHARS;
-            ctx.logger.progress(1, "Speech transcription complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([storedJson.url, storedSrt?.url, storedText.url]),
-                    primary_file_url: storedJson.url,
-                    sourceUrl: payload.source_url,
-                    text: inlineOk ? transcription.text : transcription.text.slice(0, MAX_INLINE_TRANSCRIPT_CHARS),
-                    text_truncated: !inlineOk,
-                    language: transcription.language,
-                    diarization: transcription.diarization,
-                    // Format 1 — SIMPLE SUBTITLE VERSION: plain transcript + SRT cues (no speakers).
-                    subtitles: {
-                        srt: inlineOk ? srt : null,
-                        srt_url: storedSrt?.url ?? null,
-                        text_url: storedText.url
-                    },
-                    // Format 2 — ADVANCED MULTI-SPEAKER VERSION: speaker-attributed timed segments.
-                    speakers,
-                    segments: inlineOk ? transcription.segments : undefined,
-                    transcript: {
-                        json_url: storedJson.url,
-                        content_type: "application/json"
-                    }
-                }
-            };
-        }
-    }
-});
-// Speech → animated captions convenience primitive. One job: transcribe the
-// narration WITH word-level timings (openai/whisper-1 real timestamps, other
-// providers estimated), page it into CapCut-style cues, and return the cue
-// list shaped EXACTLY for the editor's `editor_action set_captions` — the
-// output even carries a ready `set_captions_action` object so an agent can
-// pipe it through without any cue math. Composition-agnostic: it never
-// mutates a fork; POST /api/v1/compositions/:forkId/captions is the one-step
-// variant that applies server-side.
-const captionsPrimitive = definePrimitive({
-    id: PRIMITIVE_CAPTIONS_ID,
-    kind: "captions",
-    operations: {
-        run: {
-            description: "Transcribe narration (or page a script) into animated word-by-word caption cues ready for the editor's set_captions action.",
-            inputSchema: captionsPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = captionsPayloadSchema.parse(input);
-            const preset = payload.style
-                ? captionStylePresetById(payload.style)
-                : payload.animation
-                    ? null
-                    : CAPTION_STYLE_PRESETS[0];
-            if (payload.style && !preset) {
-                throw new Error(`Unknown caption style "${payload.style}". Use one of: ${CAPTION_STYLE_PRESETS.map((entry) => entry.id).join(", ")} — or pass animation directly.`);
-            }
-            const animation = payload.animation ?? preset?.animation ?? "highlight-pop";
-            let cues;
-            let wordTimestampSource = "estimated";
-            let transcriptText = null;
-            let transcriptArtifacts = {};
-            if (payload.text?.trim()) {
-                const tokens = payload.text.trim().split(/\s+/).filter(Boolean);
-                const windowDuration = payload.window_duration ?? Math.max(0.4, tokens.length * 0.32);
-                cues = cuesFromText(payload.text, payload.window_start + payload.offset_sec, windowDuration, {
-                    maxWordsPerCue: payload.max_words_per_cue
-                });
-            }
-            else {
-                const { audioBytes, audioContentType } = await loadSpeechAudioForPrimitive(ctx, {
-                    source_url: payload.source_url,
-                    media_type: payload.media_type
-                });
-                ctx.logger.progress(0.45, "Transcribing speech with word timings");
-                // openai first: whisper-1 is the only provider with REAL word-level
-                // timestamps; providerAttempts falls back to the caller's other keys.
-                const provider = payload.provider ?? "openai";
-                const model = payload.model ?? defaultSpeechModelFor("stt", provider) ?? "";
-                const transcription = await ctx.providers.transcribeSpeech({
-                    provider,
-                    model,
-                    audio: audioBytes,
-                    contentType: audioContentType,
-                    prompt: payload.prompt,
-                    language: payload.language,
-                    diarize: false,
-                    wordTimestamps: true
-                });
-                if (!transcription.segments.length) {
-                    throw new Error("Transcription returned no speech segments — the source may be silent.");
-                }
-                transcriptText = transcription.text || null;
-                wordTimestampSource = transcription.segments.some((segment) => segment.words?.length) ? "provider" : "estimated";
-                ctx.logger.progress(0.7, "Paging transcript into caption cues");
-                cues = buildCaptionCues(transcription.segments, {
-                    maxWordsPerCue: payload.max_words_per_cue,
-                    offsetSec: payload.offset_sec
-                });
-                const srt = buildSrtFromSegments(transcription.segments);
-                const storedSrt = srt ? await ctx.storage.putText("transcript.srt", srt, "application/x-subrip; charset=utf-8") : null;
-                if (storedSrt?.url)
-                    transcriptArtifacts.srt_url = storedSrt.url;
-            }
-            if (!cues.length) {
-                throw new Error("No caption cues produced from the source.");
-            }
-            // Style echo in the exact field names editor_action set_captions takes,
-            // so the agent can spread this straight into the action.
-            const styleFields = {
-                ...(preset ? { caption_style: preset.id } : {}),
-                caption_animation: animation,
-                ...(payload.active_color ?? preset?.activeColor ? { caption_active_color: payload.active_color ?? preset?.activeColor } : {}),
-                ...(payload.highlight_color ?? preset?.highlightColor ? { caption_highlight_color: payload.highlight_color ?? preset?.highlightColor } : {}),
-                ...((payload.uppercase ?? preset?.uppercase) !== undefined ? { caption_uppercase: payload.uppercase ?? preset?.uppercase } : {}),
-                ...(payload.color ?? preset?.color ? { color: payload.color ?? preset?.color } : {}),
-                ...(payload.background ?? preset?.background ? { background: payload.background ?? preset?.background } : {}),
-                ...(payload.background_style ?? preset?.textBackgroundStyle ? { background_style: payload.background_style ?? preset?.textBackgroundStyle } : {}),
-                ...(payload.font_family ? { font_family: payload.font_family } : {}),
-                ...(payload.font_size ? { font_size: payload.font_size } : {})
-            };
-            const setCaptionsAction = {
-                action_type: "set_captions",
-                captions: cues,
-                ...styleFields,
-                explanation: "Apply transcribed animated captions."
-            };
-            ctx.logger.progress(0.85, "Storing caption artifacts");
-            const storedCaptions = await ctx.storage.putJson("captions.json", {
-                source_url: payload.source_url ?? null,
-                word_timestamps: wordTimestampSource,
-                style: styleFields,
-                cue_count: cues.length,
-                cues,
-                set_captions_action: setCaptionsAction,
-                ...(transcriptText ? { transcript_text: transcriptText } : {})
-            });
-            const cuesInline = JSON.stringify(cues).length <= 60_000;
-            ctx.logger.progress(1, "Caption cues ready");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([storedCaptions.url, transcriptArtifacts.srt_url]),
-                    primary_file_url: storedCaptions.url,
-                    cue_count: cues.length,
-                    word_timestamps: wordTimestampSource,
-                    ...styleFields,
-                    // The cue list, ready to pass as editor_action set_captions `captions`.
-                    captions: cuesInline ? cues : undefined,
-                    captions_truncated: !cuesInline,
-                    // Fully-formed editor_action arguments — apply verbatim.
-                    set_captions_action: cuesInline ? setCaptionsAction : undefined,
-                    captions_json_url: storedCaptions.url,
-                    transcript: transcriptArtifacts.srt_url ? { srt_url: transcriptArtifacts.srt_url } : undefined
-                }
-            };
-        }
-    }
-});
-// Voice-casting hints for the profiling prompt: the exact preset names each
-// provider accepts (imported lists are the guard), annotated so an audio-native
-// model can pick the closest match to what it hears.
-const OPENAI_VOICE_CASTING_HINTS = "alloy (neutral, balanced), ash (warm, mature male), ballad (calm British male), cedar (deep, steady male), coral (warm, friendly female), echo (confident male), fable (bright British, androgynous), marin (clear, upbeat female), nova (energetic young female), onyx (deep, authoritative male), sage (soft, gentle female), shimmer (crisp, expressive female), verse (versatile, expressive male)";
-const GEMINI_VOICE_CASTING_HINTS = "Zephyr (bright female), Puck (upbeat male), Charon (informative male), Kore (firm female), Fenrir (excitable male), Leda (youthful female), Orus (firm male), Aoede (breezy female), Callirrhoe (easy-going female), Autonoe (bright female), Enceladus (breathy male), Iapetus (clear male), Umbriel (easy-going male), Algieba (smooth male), Despina (smooth female), Erinome (clear female), Algenib (gravelly male), Rasalgethi (informative male), Laomedeia (upbeat female), Achernar (soft female), Alnilam (firm male), Schedar (even male), Gacrux (mature female), Pulcherrima (forward female), Achird (friendly male), Zubenelgenubi (casual male), Vindemiatrix (gentle female), Sadachbia (lively male), Sadaltager (knowledgeable male), Sulafat (warm female)";
-// Loose on purpose: a shape miss must degrade to transcript-only, never fail
-// the whole regeneration job.
-const speechVoiceProfileResultSchema = z.object({
-    transcript: z.string().optional().default(""),
-    language: z.string().nullish(),
-    voice_profile: z.object({
-        gender: z.string().nullish(),
-        age_range: z.string().nullish(),
-        accent: z.string().nullish(),
-        pace: z.string().nullish(),
-        pitch: z.string().nullish(),
-        energy: z.string().nullish(),
-        tone: z.string().nullish()
-    }).nullish(),
-    style_instructions: z.string().nullish(),
-    recommended_voice: z.object({
-        openai: z.string().nullish(),
-        gemini: z.string().nullish()
-    }).nullish()
-});
-const speechRewriteResultSchema = z.object({
-    script: z.string().min(1)
-});
-function buildVoiceProfilePrompt(language) {
-    return [
-        "You are a professional voice-casting director. Listen to the attached audio.",
-        "Profile the dominant speaker and transcribe their words verbatim (if several people speak, profile only the dominant speaker and transcribe only their words).",
-        "Return STRICT JSON ONLY with this exact shape:",
-        `{"transcript": "<verbatim words spoken>", "language": "<BCP-47 code or null>", "voice_profile": {"gender": "...", "age_range": "...", "accent": "...", "pace": "...", "pitch": "...", "energy": "...", "tone": "..."}, "style_instructions": "<2-4 sentences>", "recommended_voice": {"openai": "<one name>", "gemini": "<one name>"}}`,
-        "style_instructions must be a dense free-form text-to-speech voice direction that would make a voice actor sound as close as possible to this speaker: accent, pacing, pitch, energy, emotion, attitude, and delivery quirks (pauses, emphasis, breathiness, smile, hesitations).",
-        `recommended_voice.openai must be exactly one name from: ${OPENAI_VOICE_CASTING_HINTS}.`,
-        `recommended_voice.gemini must be exactly one name from: ${GEMINI_VOICE_CASTING_HINTS}.`,
-        "Pick the preset closest to the speaker's gender, age, and timbre.",
-        ...(language?.trim() ? [`Expected language: ${language.trim()}.`] : [])
-    ].join("\n");
-}
-function buildSpeechRewritePrompt(input) {
-    return [
-        "You rewrite spoken-word scripts. Rewrite the original transcript below, following the instruction, as words to be SPOKEN aloud by the same person.",
-        "Rules:",
-        "- Keep roughly the same length and rhythm as the original unless the instruction says otherwise (the new audio should fill a similar duration).",
-        "- Keep the speaker's register, energy, and phrasing style; this must sound like the same person talking.",
-        "- Plain spoken words only: no stage directions, no markdown, no quotes, no speaker labels, no timestamps.",
-        ...(input.language?.trim() ? [`- Write the script in this language: ${input.language.trim()}.`] : ["- Write in the same language as the original transcript."]),
-        `Return STRICT JSON ONLY with shape {"script": "..."}.`,
-        "",
-        `Instruction: ${input.instruction}`,
-        "",
-        "Original transcript:",
-        input.transcript
-    ].join("\n");
-}
-// Voice-matched speech regeneration ("same voice, new words"). Pipeline:
-// (1) load the source audio (videos are demuxed), (2) profile the speaker with
-// an audio-native LLM — verbatim transcript + voice profile + closest preset
-// voices in ONE call (needs a saved Gemini key; without one this degrades to a
-// plain STT transcript and no voice match), (3) reword the transcript per
-// rewrite_instruction unless an exact `text` script was given, (4) TTS with
-// the matched preset + profiled style instructions. Neither OpenAI nor Gemini
-// exposes voice cloning through their public APIs (preset voices only; actual
-// cloning is sales-allowlisted at both), so voice_match is always an honest
-// approximation, never a clone.
-const speechRegeneratePrimitive = definePrimitive({
-    id: PRIMITIVE_SPEECH_REGENERATE_ID,
-    kind: "speech_regenerate",
-    operations: {
-        run: {
-            description: "Regenerate the speech of a video/audio source as new AI audio that sounds like the original speaker (closest preset voice + matched style direction — an approximation, not a clone), speaking a reworded or replacement script.",
-            inputSchema: speechRegeneratePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = speechRegeneratePayloadSchema.parse(input);
-            const { audioBytes, audioContentType, audioUrl } = await loadSpeechAudioForPrimitive(ctx, payload);
-            // Step 1 — hear the speaker. One Gemini call returns transcript + voice
-            // profile together; a failure here must never sink the job.
-            const available = ctx.providers.listAvailableProviders();
-            let profile = null;
-            if (available.includes("gemini") && audioUrl) {
-                ctx.logger.progress(0.3, "Profiling the original voice");
-                try {
-                    const profiled = await runBrainstormJson(ctx, {
-                        kind: "speech_voice_profile",
-                        provider: "gemini",
-                        prompt: buildVoiceProfilePrompt(payload.language),
-                        attachments: [audioUrl],
-                        resultSchema: speechVoiceProfileResultSchema
-                    });
-                    profile = profiled.result;
-                }
-                catch (error) {
-                    ctx.logger.warn("Voice profiling failed; continuing without a voice match", {
-                        error: error instanceof Error ? error.message : String(error)
-                    });
-                }
-            }
-            let originalTranscript = profile?.transcript?.trim() || "";
-            if (!originalTranscript && payload.rewrite_instruction) {
-                ctx.logger.progress(0.4, "Transcribing original speech");
-                const sttProvider = ["gemini", "openai", "openrouter"].find((provider) => available.includes(provider)) ?? "gemini";
-                const transcription = await ctx.providers.transcribeSpeech({
-                    provider: sttProvider,
-                    model: defaultSpeechModelFor("stt", sttProvider) ?? "",
-                    audio: audioBytes,
-                    contentType: audioContentType,
-                    language: payload.language,
-                    diarize: false
-                });
-                originalTranscript = transcription.text.trim();
-                if (!originalTranscript) {
-                    throw new Error("The source has no transcribable speech to reword. Pass text with the exact script instead.");
-                }
-            }
-            // Step 2 — the words: exact script wins, otherwise reword the transcript.
-            let script = payload.text?.trim() ?? "";
-            if (!script) {
-                ctx.logger.progress(0.5, "Rewording the script");
-                const rewrite = await runBrainstormJson(ctx, {
-                    kind: "speech_rewrite",
-                    prompt: buildSpeechRewritePrompt({
-                        transcript: originalTranscript,
-                        instruction: payload.rewrite_instruction,
-                        language: payload.language ?? profile?.language ?? null
-                    }),
-                    resultSchema: speechRewriteResultSchema
-                });
-                script = rewrite.result.script.trim();
-            }
-            if (!script) {
-                throw new Error("No script produced to speak.");
-            }
-            if (script.length > 8000) {
-                throw new Error("The regenerated script is too long for TTS (8000 characters max). Trim the source with /audio/trim or narrow the rewrite_instruction.");
-            }
-            // Step 3 — voice + style. openai first when nothing else decides: its
-            // TTS takes the style `instructions` natively (gemini gets them
-            // prepended into the prompt). A bare payload voice implies its provider.
-            const provider = payload.provider
-                ?? inferSpeechProviderForVoice(payload.voice)
-                ?? ["openai", "gemini", "openrouter"].find((candidate) => available.includes(candidate))
-                ?? "openai";
-            const model = payload.model ?? defaultSpeechModelFor("tts", provider) ?? "";
-            const family = speechVoiceFamilyFor(provider, model);
-            const presets = family === "gemini" ? GEMINI_TTS_VOICES : OPENAI_TTS_VOICES;
-            const recommendedRaw = (family === "gemini" ? profile?.recommended_voice?.gemini : profile?.recommended_voice?.openai)?.trim().toLowerCase();
-            const recommendedVoice = recommendedRaw ? presets.find((preset) => preset.toLowerCase() === recommendedRaw) : undefined;
-            const voice = payload.voice ?? recommendedVoice;
-            const profiledStyle = profile?.style_instructions?.trim();
-            const instructions = [profiledStyle, payload.instructions?.trim()].filter(Boolean).join(" ") || undefined;
-            ctx.logger.progress(0.65, "Generating voice-matched speech");
-            const generated = await ctx.providers.generateSpeech({
-                provider,
-                model,
-                text: script,
-                voice,
-                instructions,
-                responseFormat: payload.output_format
-            });
-            const extension = generated.contentType.includes("wav") ? "wav" : "mp3";
-            const stored = await ctx.storage.putBuffer(`speech.${extension}`, generated.bytes, {
-                contentType: generated.contentType,
-                kind: "audio",
-                metadata: {
-                    primitive: "speech_regenerate",
-                    provider,
-                    model,
-                    voice: voice ?? null,
-                    styleInstructions: instructions ?? null
-                }
-            });
-            ctx.logger.progress(0.9, "Storing regeneration artifacts");
-            const voiceMatch = profiledStyle || recommendedVoice ? "approximate" : "none";
-            const voiceMatchNote = voiceMatch === "approximate"
-                ? "The audio uses the closest preset voice with style instructions matched to the original speaker. OpenAI/Gemini APIs cannot clone voice identity, so this is an approximation, not a clone."
-                : "No voice profile was available (profiling needs a saved Gemini key), so a default or explicitly requested preset voice was used without matching the original speaker.";
-            const storedJson = await ctx.storage.putJson("regenerate-speech.json", {
-                source_url: payload.source_url,
-                provider,
-                model,
-                voice: voice ?? null,
-                style_instructions: instructions ?? null,
-                voice_match: voiceMatch,
-                voice_match_note: voiceMatchNote,
-                voice_profile: profile?.voice_profile ?? null,
-                original_transcript: originalTranscript || null,
-                rewrite_instruction: payload.rewrite_instruction ?? null,
-                script,
-                audio_url: stored.url
-            });
-            ctx.logger.progress(1, "Speech regeneration complete");
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([stored.url, storedJson.url]),
-                    primary_file_url: stored.url,
-                    audioUrl: stored.url,
-                    script,
-                    original_transcript: originalTranscript ? originalTranscript.slice(0, MAX_INLINE_TRANSCRIPT_CHARS) : null,
-                    voice_match: voiceMatch,
-                    voice_match_note: voiceMatchNote,
-                    voice_profile: profile?.voice_profile ?? null,
-                    audio: {
-                        file_url: stored.url,
-                        content_type: generated.contentType,
-                        provider,
-                        model,
-                        voice: voice ?? null,
-                        style_instructions: instructions ?? null,
-                        text_length: script.length
-                    },
-                    details_json_url: storedJson.url
-                }
-            };
-        }
-    }
-});
-const videoProbePrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_PROBE_ID,
-    kind: "video_probe",
-    operations: {
-        run: {
-            description: "Probe a source video and return reusable JSON metadata.",
-            inputSchema: probeVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = probeVideoPayloadSchema.parse(input);
-            const probed = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_probe",
-                payload,
-                outputKey: "probe.json"
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, probed.publicUrl]),
-                    sourceVideoUrl: payload.source_video_url,
-                    metadataUrl: probed.publicUrl,
-                    primary_file_url: probed.publicUrl,
-                    probe: probed.metadata
-                }
-            };
-        }
-    }
-});
-const audioProbePrimitive = definePrimitive({
-    id: PRIMITIVE_AUDIO_PROBE_ID,
-    kind: "audio_probe",
-    operations: {
-        run: {
-            description: "Probe a source audio file and return reusable JSON metadata.",
-            inputSchema: probeAudioPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = probeAudioPayloadSchema.parse(input);
-            const probed = await executePrimitiveMediaOperation(ctx, {
-                operation: "audio_probe",
-                payload,
-                outputKey: "probe.json"
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_audio_url, probed.publicUrl]),
-                    sourceAudioUrl: payload.source_audio_url,
-                    metadataUrl: probed.publicUrl,
-                    primary_file_url: probed.publicUrl,
-                    probe: probed.metadata
-                }
-            };
-        }
-    }
-});
-const videoExtractFramePrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_EXTRACT_FRAME_ID,
-    kind: "video_extract_frame",
-    operations: {
-        run: {
-            description: "Extract a single frame from a source video into a reusable image file.",
-            inputSchema: extractFramePayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = extractFramePayloadSchema.parse(input);
-            const frame = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_extract_frame",
-                payload,
-                outputKey: `frame.${payload.output_format === "jpeg" ? "jpg" : payload.output_format}`
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, frame.publicUrl]),
-                    sourceVideoUrl: payload.source_video_url,
-                    primary_file_url: frame.publicUrl,
-                    image: {
-                        file_url: frame.publicUrl,
-                        content_type: frame.contentType,
-                        extracted_from_url: payload.source_video_url
-                    },
-                    frame: frame.metadata
-                }
-            };
-        }
-    }
-});
-const videoMutePrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_MUTE_ID,
-    kind: "video_mute",
-    operations: {
-        run: {
-            description: "Remove audio from a source video and return a reusable muted MP4.",
-            inputSchema: muteVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = muteVideoPayloadSchema.parse(input);
-            const muted = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_mute",
-                payload,
-                outputKey: "muted.mp4"
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, muted.publicUrl]),
-                    sourceVideoUrl: payload.source_video_url,
-                    mutedVideoUrl: muted.publicUrl,
-                    primary_file_url: muted.publicUrl,
-                    video: {
-                        file_url: muted.publicUrl,
-                        content_type: muted.contentType,
-                        mute: muted.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const videoReplaceAudioPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_REPLACE_AUDIO_ID,
-    kind: "video_replace_audio",
-    operations: {
-        run: {
-            description: "Replace a source video's audio track with another audio file.",
-            inputSchema: replaceAudioPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = replaceAudioPayloadSchema.parse(input);
-            const replaced = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_replace_audio",
-                payload,
-                outputKey: "replaced-audio.mp4"
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_video_url, payload.source_audio_url, replaced.publicUrl]),
-                    sourceVideoUrl: payload.source_video_url,
-                    sourceAudioUrl: payload.source_audio_url,
-                    primary_file_url: replaced.publicUrl,
-                    video: {
-                        file_url: replaced.publicUrl,
-                        content_type: replaced.contentType,
-                        audio_replacement: replaced.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const videoConcatPrimitive = definePrimitive({
-    id: PRIMITIVE_VIDEO_CONCAT_ID,
-    kind: "video_concat",
-    operations: {
-        run: {
-            description: "Concatenate multiple source videos into one reusable MP4.",
-            inputSchema: concatVideoPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = concatVideoPayloadSchema.parse(input);
-            const concatenated = await executePrimitiveMediaOperation(ctx, {
-                operation: "video_concat",
-                payload,
-                outputKey: "concat.mp4"
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([...payload.source_video_urls, concatenated.publicUrl]),
-                    sourceVideoUrls: payload.source_video_urls,
-                    primary_file_url: concatenated.publicUrl,
-                    video: {
-                        file_url: concatenated.publicUrl,
-                        content_type: concatenated.contentType,
-                        concat: concatenated.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const audioConcatPrimitive = definePrimitive({
-    id: PRIMITIVE_AUDIO_CONCAT_ID,
-    kind: "audio_concat",
-    operations: {
-        run: {
-            description: "Concatenate multiple source audio files into one reusable audio file.",
-            inputSchema: concatAudioPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = concatAudioPayloadSchema.parse(input);
-            const concatenated = await executePrimitiveMediaOperation(ctx, {
-                operation: "audio_concat",
-                payload,
-                outputKey: `concat.${payload.output_format}`
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([...payload.source_audio_urls, concatenated.publicUrl]),
-                    sourceAudioUrls: payload.source_audio_urls,
-                    primary_file_url: concatenated.publicUrl,
-                    audio: {
-                        file_url: concatenated.publicUrl,
-                        content_type: concatenated.contentType,
-                        concat: concatenated.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const audioNormalizePrimitive = definePrimitive({
-    id: PRIMITIVE_AUDIO_NORMALIZE_ID,
-    kind: "audio_normalize",
-    operations: {
-        run: {
-            description: "Normalize a source audio file into a reusable platform audio file.",
-            inputSchema: normalizeAudioPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = normalizeAudioPayloadSchema.parse(input);
-            const normalized = await executePrimitiveMediaOperation(ctx, {
-                operation: "audio_normalize",
-                payload,
-                outputKey: `normalized.${payload.output_format}`
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([payload.source_audio_url, normalized.publicUrl]),
-                    sourceAudioUrl: payload.source_audio_url,
-                    normalizedAudioUrl: normalized.publicUrl,
-                    primary_file_url: normalized.publicUrl,
-                    audio: {
-                        file_url: normalized.publicUrl,
-                        content_type: normalized.contentType,
-                        normalization: normalized.metadata
-                    }
-                }
-            };
-        }
-    }
-});
-const hyperframesRenderPrimitive = definePrimitive({
-    id: PRIMITIVE_HYPERFRAMES_RENDER_ID,
-    kind: "hyperframes_render",
-    operations: {
-        run: {
-            description: "Render a timeline/layer composition to MP4 with production Lambda.",
-            inputSchema: hyperframesRenderPayloadSchema,
-            workflow: "run"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = hyperframesRenderPayloadSchema.parse(input);
-            ctx.logger.progress(0.08, "Preparing timeline render");
-            const composition = payload.composition ? normalizeHyperframesCompositionPayload(payload.composition) : undefined;
-            const compositionHtml = payload.composition_html;
-            const compositionDataArtifact = payload.composition_data
-                ? await ctx.storage.putJson("composition.json", payload.composition_data)
-                : null;
-            const render = await ctx.hyperframes.render({
-                compositionHtml,
-                composition,
-                compositionId: payload.composition_id ?? composition?.compositionId,
-                title: payload.title ?? composition?.title,
-                width: payload.width ?? composition?.width,
-                height: payload.height ?? composition?.height,
-                fps: payload.fps,
-                chunkSize: payload.chunk_size,
-                maxParallelChunks: payload.max_parallel_chunks,
-                outputKey: payload.output_key,
-                projectFiles: payload.project_files.map((file) => ({
-                    path: file.path,
-                    contents: readHyperframesProjectFileContents(file),
-                    contentType: file.content_type
-                }))
-            });
-            ctx.logger.progress(1, "Timeline render complete", {
-                renderId: render.renderId,
-                outputUrl: render.outputUrl,
-                outputS3Uri: render.outputS3Uri
-            });
-            return {
-                progress: 1,
-                output: {
-                    files: compactUrls([render.outputUrl, compositionDataArtifact?.url]),
-                    primary_file_url: render.outputUrl,
-                    video: {
-                        file_url: render.outputUrl,
-                        content_type: "video/mp4",
-                        width: payload.width ?? composition?.width ?? null,
-                        height: payload.height ?? composition?.height ?? null,
-                        fps: payload.fps
-                    },
-                    render: {
-                        render_id: render.renderId,
-                        output_url: render.outputUrl,
-                        output_s3_uri: render.outputS3Uri,
-                        metadata: render.metadata
-                    },
-                    hyperframes: {
-                        composition_id: payload.composition_id ?? composition?.compositionId ?? null,
-                        composition_data_url: compositionDataArtifact?.url ?? null,
-                        architecture: "timeline_layers"
-                    }
-                }
-            };
-        }
-    }
-});
-const brainstormHooksPrimitive = definePrimitive({
-    id: PRIMITIVE_BRAINSTORM_HOOKS_ID,
-    kind: "brainstorm_hooks",
-    operations: {
-        run: {
-            description: "Generate diverse TikTok-native ad hooks plus short explanations for a provided offer.",
-            inputSchema: brainstormHooksPayloadSchema,
-            workflow: "run",
-            providerHint: "openai"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = brainstormHooksPayloadSchema.parse(input);
-            ctx.logger.progress(0.15, "Brainstorming hooks");
-            const generated = await runBrainstormJson(ctx, {
-                kind: "brainstorm_hooks",
-                provider: payload.provider,
-                model: payload.model,
-                prompt: buildHooksPrompt(payload.offer_description, payload.count),
-                resultSchema: brainstormHooksResultSchema
-            });
-            const promptArtifact = await ctx.storage.putText("prompt.txt", buildHooksPrompt(payload.offer_description, payload.count));
-            const resultArtifact = await ctx.storage.putJson("result.json", generated.result);
-            ctx.logger.progress(1, "Hook brainstorm complete");
-            return {
-                progress: 1,
-                output: {
-                    hooks: generated.result.hooks,
-                    files: compactUrls([resultArtifact.url, promptArtifact.url]),
-                    artifacts: {
-                        prompt_url: promptArtifact.url,
-                        result_url: resultArtifact.url
-                    },
-                    usage: generated.usage
-                }
-            };
-        }
-    }
-});
-const brainstormAwarenessStagesPrimitive = definePrimitive({
-    id: PRIMITIVE_BRAINSTORM_AWARENESS_STAGES_ID,
-    kind: "brainstorm_awareness_stages",
-    operations: {
-        run: {
-            description: "Explain which awareness stages to target first for an offer and what ad types to create.",
-            inputSchema: brainstormAwarenessStagesPayloadSchema,
-            workflow: "run",
-            providerHint: "openai"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = brainstormAwarenessStagesPayloadSchema.parse(input);
-            ctx.logger.progress(0.15, "Mapping awareness stages");
-            const prompt = buildAwarenessStagesPrompt(payload.offer_description);
-            const generated = await runBrainstormText(ctx, {
-                kind: "brainstorm_awareness_stages",
-                provider: payload.provider,
-                model: payload.model,
-                prompt,
-                temperature: 0.55
-            });
-            const promptArtifact = await ctx.storage.putText("prompt.txt", prompt);
-            const resultArtifact = await ctx.storage.putText("response.md", generated.text, "text/markdown; charset=utf-8");
-            ctx.logger.progress(1, "Awareness-stage brainstorm complete");
-            return {
-                progress: 1,
-                output: {
-                    response: generated.text,
-                    files: compactUrls([resultArtifact.url, promptArtifact.url]),
-                    artifacts: {
-                        prompt_url: promptArtifact.url,
-                        response_url: resultArtifact.url
-                    },
-                    usage: generated.usage
-                }
-            };
-        }
-    }
-});
-const brainstormAnglesPrimitive = definePrimitive({
-    id: PRIMITIVE_BRAINSTORM_ANGLES_ID,
-    kind: "brainstorm_angles",
-    operations: {
-        run: {
-            description: "Generate diverse persuasive TikTok advertising angles for an offer at the selected awareness levels.",
-            inputSchema: brainstormAnglesPayloadSchema,
-            workflow: "run",
-            providerHint: "openai"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = brainstormAnglesPayloadSchema.parse(input);
-            ctx.logger.progress(0.15, "Brainstorming angles");
-            const prompt = buildAnglesPrompt(payload);
-            const generated = await runBrainstormJson(ctx, {
-                kind: "brainstorm_angles",
-                provider: payload.provider,
-                model: payload.model,
-                prompt,
-                resultSchema: brainstormAnglesResultSchema
-            });
-            const promptArtifact = await ctx.storage.putText("prompt.txt", prompt);
-            const resultArtifact = await ctx.storage.putJson("result.json", generated.result);
-            ctx.logger.progress(1, "Angle brainstorm complete");
-            return {
-                progress: 1,
-                output: {
-                    angles: generated.result.angles,
-                    awareness: {
-                        problem_awareness: payload.problem_awareness,
-                        solution_awareness: payload.solution_awareness
-                    },
-                    files: compactUrls([resultArtifact.url, promptArtifact.url]),
-                    artifacts: {
-                        prompt_url: promptArtifact.url,
-                        result_url: resultArtifact.url
-                    },
-                    usage: generated.usage
-                }
-            };
-        }
-    }
-});
-const brainstormColdstartPrimitive = definePrimitive({
-    id: PRIMITIVE_BRAINSTORM_COLDSTART_ID,
-    kind: "brainstorm_coldstart",
-    operations: {
-        run: {
-            description: "Generate a high-signal cold-start questionnaire that helps a customer build a TikTok content strategy from zero.",
-            inputSchema: brainstormColdstartPayloadSchema,
-            workflow: "run",
-            providerHint: "openai"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = brainstormColdstartPayloadSchema.parse(input);
-            ctx.logger.progress(0.15, "Generating cold-start questions");
-            const prompt = buildColdstartPrompt(payload.user_message, payload.count);
-            const generated = await runBrainstormJson(ctx, {
-                kind: "brainstorm_coldstart",
-                provider: payload.provider,
-                model: payload.model,
-                prompt,
-                resultSchema: brainstormColdstartResultSchema
-            });
-            const promptArtifact = await ctx.storage.putText("prompt.txt", prompt);
-            const resultArtifact = await ctx.storage.putJson("result.json", generated.result);
-            ctx.logger.progress(1, "Cold-start questionnaire complete");
-            return {
-                progress: 1,
-                output: {
-                    questions: generated.result.questions,
-                    encouragement: "Encourage the user to save their answers in a Google Doc or markdown file and upload that context into Vidfarm for future strategy, scripting, and template runs.",
-                    files: compactUrls([resultArtifact.url, promptArtifact.url]),
-                    artifacts: {
-                        prompt_url: promptArtifact.url,
-                        result_url: resultArtifact.url
-                    },
-                    usage: generated.usage
-                }
-            };
-        }
-    }
-});
-const brainstormProductPlacementPrimitive = definePrimitive({
-    id: PRIMITIVE_BRAINSTORM_PRODUCT_PLACEMENT_ID,
-    kind: "brainstorm_product_placement",
-    operations: {
-        run: {
-            description: "Watch a source video and identify concrete, timestamped product-placement opportunities for a given product/offer.",
-            inputSchema: brainstormProductPlacementPayloadSchema,
-            workflow: "run",
-            providerHint: "gemini"
-        }
-    },
-    jobs: {
-        async run(ctx, input) {
-            const payload = brainstormProductPlacementPayloadSchema.parse(input);
-            ctx.logger.progress(0.15, "Analyzing video for product placement opportunities");
-            const provider = payload.provider ?? preferredVideoTextProvider(ctx.providers.listAvailableProviders());
-            const prompt = buildProductPlacementPrompt(payload.offer_description, payload.count);
-            const generated = await runBrainstormJson(ctx, {
-                kind: "brainstorm_product_placement",
-                provider,
-                model: payload.model,
-                prompt,
-                attachments: [payload.source_video_url],
-                resultSchema: brainstormProductPlacementResultSchema
-            });
-            const promptArtifact = await ctx.storage.putText("prompt.txt", prompt);
-            const resultArtifact = await ctx.storage.putJson("result.json", generated.result);
-            ctx.logger.progress(1, "Product-placement analysis complete");
-            return {
-                progress: 1,
-                output: {
-                    opportunities: generated.result.opportunities,
-                    source_video_url: payload.source_video_url,
-                    files: compactUrls([resultArtifact.url, promptArtifact.url]),
-                    artifacts: {
-                        prompt_url: promptArtifact.url,
-                        result_url: resultArtifact.url
-                    },
-                    usage: generated.usage
-                }
-            };
-        }
-    }
-});
-class PrimitiveRegistry {
-    definitions = new Map([
-        [imageGeneratePrimitive.id, imageGeneratePrimitive],
-        [imageEditPrimitive.id, imageEditPrimitive],
-        [imageInpaintPrimitive.id, imageInpaintPrimitive],
-        [imageRenderHtmlPrimitive.id, imageRenderHtmlPrimitive],
-        [imageRemoveBackgroundPrimitive.id, imageRemoveBackgroundPrimitive],
-        [imageRemoveBackgroundGreenscreenPrimitive.id, imageRemoveBackgroundGreenscreenPrimitive],
-        [mediaOverlayPrimitive.id, mediaOverlayPrimitive],
-        [videoGeneratePrimitive.id, videoGeneratePrimitive],
-        [videoRenderSlidesPrimitive.id, videoRenderSlidesPrimitive],
-        [mediaDedupePrimitive.id, mediaDedupePrimitive],
-        [videoNormalizePrimitive.id, videoNormalizePrimitive],
-        [videoDownloadPrimitive.id, videoDownloadPrimitive],
-        [videoIngestPrimitive.id, videoIngestPrimitive],
-        [videoTrimPrimitive.id, videoTrimPrimitive],
-        [videoRemoveCaptionsPrimitive.id, videoRemoveCaptionsPrimitive],
-        [videoExtractAudioPrimitive.id, videoExtractAudioPrimitive],
-        [audioTrimPrimitive.id, audioTrimPrimitive],
-        [videoProbePrimitive.id, videoProbePrimitive],
-        [audioProbePrimitive.id, audioProbePrimitive],
-        [videoExtractFramePrimitive.id, videoExtractFramePrimitive],
-        [videoMutePrimitive.id, videoMutePrimitive],
-        [videoReplaceAudioPrimitive.id, videoReplaceAudioPrimitive],
-        [videoConcatPrimitive.id, videoConcatPrimitive],
-        [audioConcatPrimitive.id, audioConcatPrimitive],
-        [audioNormalizePrimitive.id, audioNormalizePrimitive],
-        [ttsPrimitive.id, ttsPrimitive],
-        [sttPrimitive.id, sttPrimitive],
-        [musicPrimitive.id, musicPrimitive],
-        [captionsPrimitive.id, captionsPrimitive],
-        [speechRegeneratePrimitive.id, speechRegeneratePrimitive],
-        [hyperframesRenderPrimitive.id, hyperframesRenderPrimitive],
-        [brainstormHooksPrimitive.id, brainstormHooksPrimitive],
-        [brainstormAwarenessStagesPrimitive.id, brainstormAwarenessStagesPrimitive],
-        [brainstormAnglesPrimitive.id, brainstormAnglesPrimitive],
-        [brainstormColdstartPrimitive.id, brainstormColdstartPrimitive],
-        [brainstormProductPlacementPrimitive.id, brainstormProductPlacementPrimitive]
-    ]);
-    get(id) {
-        return this.definitions.get(id) ?? null;
-    }
-    getByKind(kind) {
-        return this.list().find((definition) => definition.kind === kind) ?? null;
-    }
-    list() {
-        return [...this.definitions.values()];
-    }
-}
-export const primitiveRegistry = new PrimitiveRegistry();
-function normalizeHyperframesCompositionPayload(payload) {
-    const duration = payload.duration_seconds ?? payload.duration ?? payload.layers.reduce((max, layer) => Math.max(max, layer.start + layer.duration), 0);
-    return {
-        compositionId: payload.composition_id,
-        title: payload.title,
-        sourceFolder: payload.source_folder,
-        width: payload.width,
-        height: payload.height,
-        duration,
-        backgroundColor: payload.background_color,
-        css: payload.css,
-        layers: payload.layers.map((layer) => ({
-            id: layer.id,
-            kind: layer.kind,
-            label: layer.label,
-            mode: layer.mode,
-            start: layer.start,
-            duration: layer.duration,
-            track: layer.track,
-            z: layer.z,
-            x: layer.x,
-            y: layer.y,
-            width: layer.width,
-            height: layer.height,
-            src: layer.src,
-            mediaStart: layer.mediaStart ?? layer.media_start,
-            playbackStart: layer.playbackStart ?? layer.playback_start ?? layer.mediaStart ?? layer.media_start,
-            fit: layer.fit,
-            muted: layer.muted,
-            volume: layer.volume,
-            text: layer.text,
-            html: layer.html,
-            color: layer.color,
-            background: layer.background,
-            textBackgroundStyle: layer.textBackgroundStyle ?? layer.text_background_style,
-            fontFamily: layer.fontFamily ?? layer.font_family,
-            fontWeight: layer.fontWeight ?? layer.font_weight,
-            fontSize: layer.fontSize ?? layer.font_size,
-            lineHeight: layer.lineHeight ?? layer.line_height,
-            radius: layer.radius,
-            opacity: layer.opacity,
-            viralAlignment: layer.viralAlignment ?? layer.viral_alignment
-        }))
-    };
-}
-async function storePrimitiveImage(ctx, input) {
-    const stored = await ctx.storage.putBuffer(input.key, input.bytes, {
-        contentType: input.contentType,
-        kind: "image",
-        metadata: input.metadata
-    });
-    return { ...stored, contentType: input.contentType };
-}
-async function storePrimitiveVideo(ctx, input) {
-    const stored = await ctx.storage.putBuffer(input.key, input.bytes, {
-        contentType: input.contentType,
-        kind: "video",
-        metadata: input.metadata
-    });
-    return { ...stored, contentType: input.contentType };
-}
-function buildImagePrimitiveOutput(input) {
-    return {
-        files: input.files,
-        primary_file_url: input.fileUrl,
-        image: {
-            file_url: input.fileUrl,
-            content_type: input.contentType,
-            ...(input.revisedPrompt !== undefined ? { revised_prompt: input.revisedPrompt } : {}),
-            ...(input.derivedFromUrl ? { derived_from_url: input.derivedFromUrl } : {}),
-            ...(input.maskUrl ? { mask_url: input.maskUrl } : {})
-        }
-    };
-}
-function defaultImageModelForProvider(provider) {
-    switch (provider) {
-        case "openai":
-            return "gpt-image-2";
-        case "openrouter":
-            return "google/gemini-2.5-flash-image-preview";
-        default:
-            return "gemini-2.5-flash-image";
-    }
-}
-function defaultVideoModelForProvider(provider) {
-    switch (provider) {
-        case "openai":
-            return "sora-2";
-        case "gemini":
-            return "veo-3.0-generate-001";
-        case "openrouter":
-            return "bytedance/seedance-2.0";
-    }
-}
-function defaultTextModelForProvider(provider) {
-    switch (provider) {
-        case "gemini":
-            return "gemini-2.5-flash";
-        case "openrouter":
-            return "qwen/qwen3.6-plus";
-        case "perplexity":
-            return "sonar";
-        default:
-            return "gpt-5.4-mini";
-    }
-}
-// Extensions that are safe to feed a speech provider without the ffmpeg
-// normalization pass; everything else (video or unknown) gets demuxed first.
-function inferSpeechSourceKind(sourceUrl) {
-    return /\.(mp3|m4a|aac|ogg|oga|flac|wav)(\?|#|$)/i.test(sourceUrl) ? "audio" : "video";
-}
-function normalizeAiVideoDurationSeconds(explicitSeconds, milliseconds) {
-    const seconds = Number(explicitSeconds);
-    if (Number.isFinite(seconds) && seconds > 0) {
-        return Math.max(1, Math.round(seconds));
-    }
-    const durationMs = Number(milliseconds);
-    if (Number.isFinite(durationMs) && durationMs > 0) {
-        return Math.max(1, Math.ceil(durationMs / 1000));
-    }
-    return undefined;
-}
-function extensionForOutputFormat(format) {
-    return format === "jpeg" ? "jpg" : format;
-}
-function contentTypeForOutputFormat(format, fallback) {
-    if (format === "jpeg") {
-        return "image/jpeg";
-    }
-    if (format === "webp") {
-        return "image/webp";
-    }
-    return fallback && fallback !== "image/svg+xml" ? fallback : "image/png";
-}
-async function normalizePrimitiveImageOutput(bytes, format) {
-    const buffer = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
-    if (format === "jpeg") {
-        return {
-            bytes: await sharp(buffer).jpeg({ quality: 92 }).toBuffer(),
-            contentType: "image/jpeg"
-        };
-    }
-    if (format === "webp") {
-        return {
-            bytes: await sharp(buffer).webp({ quality: 92 }).toBuffer(),
-            contentType: "image/webp"
-        };
-    }
-    return {
-        bytes: await sharp(buffer).png().toBuffer(),
-        contentType: "image/png"
-    };
-}
-function clampByte(value) {
-    const n = Math.round(Number.isFinite(value) ? value : 0);
-    return Math.max(0, Math.min(255, n));
-}
-const NAMED_KEY_COLORS = {
-    green: [0, 255, 0],
-    lime: [0, 255, 0],
-    "chroma-green": [0, 177, 64],
-    "chromakey-green": [0, 177, 64],
-    white: [255, 255, 255],
-    black: [0, 0, 0],
-    blue: [0, 0, 255],
-    "chroma-blue": [0, 71, 187],
-    "chromakey-blue": [0, 71, 187],
-    red: [255, 0, 0],
-    magenta: [255, 0, 255],
-    cyan: [0, 255, 255],
-    gray: [128, 128, 128],
-    grey: [128, 128, 128]
-};
-// Parse a key color from hex (#rgb / #rrggbb), rgb()/rgba() triples, or a small
-// set of named colors. Throws on anything unrecognized so a typo surfaces
-// instead of silently keying out the wrong color.
-function parseKeyColor(value) {
-    const raw = value.trim().toLowerCase();
-    const named = NAMED_KEY_COLORS[raw];
-    if (named) {
-        return { r: named[0], g: named[1], b: named[2] };
-    }
-    const rgbMatch = raw.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
-    if (rgbMatch) {
-        return { r: clampByte(Number(rgbMatch[1])), g: clampByte(Number(rgbMatch[2])), b: clampByte(Number(rgbMatch[3])) };
-    }
-    let hex = raw.startsWith("#") ? raw.slice(1) : raw;
-    if (/^[0-9a-f]{3}$/.test(hex)) {
-        hex = hex.split("").map((ch) => ch + ch).join("");
-    }
-    if (/^[0-9a-f]{6}$/.test(hex)) {
-        return {
-            r: parseInt(hex.slice(0, 2), 16),
-            g: parseInt(hex.slice(2, 4), 16),
-            b: parseInt(hex.slice(4, 6), 16)
-        };
-    }
-    throw new Error(`Unrecognized key_color "${value}". Use a hex value (e.g. #00FF00), an rgb(...) triple, or a named color (green/white/blue/black).`);
-}
-// A plain-English label for the key color so the image-generation prompt can
-// tell the model exactly which flat background to paint.
-function describeKeyColor(raw, rgb) {
-    const named = raw.trim().toLowerCase();
-    if (/green|lime/.test(named))
-        return "chroma green";
-    if (/blue/.test(named))
-        return "chroma blue";
-    if (named === "white" || (rgb.r > 240 && rgb.g > 240 && rgb.b > 240))
-        return "solid white";
-    if (named === "black" || (rgb.r < 15 && rgb.g < 15 && rgb.b < 15))
-        return "solid black";
-    if (rgb.g > rgb.r && rgb.g > rgb.b)
-        return "chroma green";
-    if (rgb.b > rgb.r && rgb.b > rgb.g)
-        return "chroma blue";
-    return "flat solid";
-}
-function buildOverlayGenerationPrompt(subject, keyHex, keyLabel) {
-    return [
-        subject.trim(),
-        "",
-        `BACKGROUND REQUIREMENT (critical for clean keying): render ONLY the subject, fully in frame, on a completely flat, uniform, evenly-lit ${keyLabel} background (target color ${keyHex}). The background must be one single solid ${keyLabel} fill — absolutely NO gradient, NO vignette, NO cast shadows or reflections on the background, and NO ${keyLabel} tones anywhere on the subject itself (avoid ${keyLabel} clothing, props, or rim light). Do not add any border, frame, text, or watermark. Give the subject clean, crisp edges against the ${keyLabel} so it can be cut out to a transparent PNG.`
-    ].join("\n");
-}
-// Local chroma-key background removal. Distance-thresholds every pixel against
-// the key color: within `tolerance` becomes fully transparent, a `softness`
-// feather band anti-aliases the edge, and (for chromatic keys) a classic
-// despill clamps the key's dominant channel so no colored fringe survives.
-async function chromaKeyRemoveBackground(source, options) {
-    const key = parseKeyColor(options.keyColor);
-    const buffer = Buffer.isBuffer(source) ? source : Buffer.from(source);
-    const { data, info } = await sharp(buffer).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
-    const channels = info.channels;
-    const maxDist = Math.sqrt(3) * 255;
-    const inner = Math.max(0, options.tolerance) * maxDist;
-    const outer = Math.max(inner + 1e-6, (options.tolerance + Math.max(0, options.softness)) * maxDist);
-    const keyChannels = [key.r, key.g, key.b];
-    const keyChroma = Math.max(...keyChannels) - Math.min(...keyChannels);
-    // Only despill chromatic keys (green/blue/etc.); white/gray/black have no hue
-    // fringe to suppress and clamping them would tint the subject.
-    const doDespill = options.despill && keyChroma >= 40;
-    const dominant = keyChannels.indexOf(Math.max(...keyChannels));
-    let keyedPixels = 0;
-    const totalPixels = info.width * info.height;
-    for (let i = 0; i < data.length; i += channels) {
-        const r = data[i];
-        const g = data[i + 1];
-        const b = data[i + 2];
-        const baseAlpha = channels === 4 ? data[i + 3] : 255;
-        const dr = r - key.r;
-        const dg = g - key.g;
-        const db = b - key.b;
-        const dist = Math.sqrt(dr * dr + dg * dg + db * db);
-        let alpha;
-        if (dist <= inner) {
-            alpha = 0;
-            keyedPixels++;
-        }
-        else if (dist >= outer) {
-            alpha = baseAlpha;
-        }
-        else {
-            const t = (dist - inner) / (outer - inner);
-            alpha = Math.round(baseAlpha * t);
-        }
-        if (doDespill && alpha > 0) {
-            if (dominant === 1)
-                data[i + 1] = Math.min(g, Math.max(r, b));
-            else if (dominant === 0)
-                data[i] = Math.min(r, Math.max(g, b));
-            else
-                data[i + 2] = Math.min(b, Math.max(r, g));
-        }
-        if (channels === 4)
-            data[i + 3] = alpha;
-    }
-    const encoded = sharp(data, { raw: { width: info.width, height: info.height, channels } });
-    const bytes = options.outputFormat === "webp"
-        ? await encoded.webp({ quality: 92, alphaQuality: 100 }).toBuffer()
-        : await encoded.png().toBuffer();
-    return {
-        bytes,
-        contentType: options.outputFormat === "webp" ? "image/webp" : "image/png",
-        width: info.width,
-        height: info.height,
-        keyedFraction: totalPixels > 0 ? keyedPixels / totalPixels : 0
-    };
-}
-async function recordPrimitiveProviderBilling(ctx, generated, kind) {
-    if (!Number.isFinite(generated.usageCostUsd) || generated.usageCostUsd <= 0) {
-        return;
-    }
-    const providerJob = generated.providerJob ?? {};
-    const providerJobId = providerJob.id ?? providerJob.generation_id;
-    const providerJobIdText = typeof providerJobId === "string" && providerJobId.trim() ? providerJobId.trim() : null;
-    await ctx.billing.record({
-        type: "ai_generation",
-        costUsd: generated.usageCostUsd,
-        idempotencyKey: providerJobIdText ? `primitive-provider:${kind}:${providerJobIdText}` : undefined,
-        occurredAtMs: Date.now(),
-        metadata: {
-            kind,
-            provider_job_id: providerJobIdText,
-            provider_job: providerJob
-        }
-    });
-}
-function readPrimitiveAsset(name) {
-    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        path.resolve(moduleDir, "assets", name),
-        path.resolve(moduleDir, "..", "src", "assets", name),
-        // Package-root copy (compiled module lives at <root>/dist/src): covers
-        // `vidfarm serve` launched from an arbitrary cwd out of the npm package.
-        path.resolve(moduleDir, "..", "..", "src", "assets", name),
-        path.resolve(process.cwd(), "dist", "src", "assets", name),
-        path.resolve(process.cwd(), "src", "assets", name)
-    ];
-    const assetPath = candidates.find((candidate) => existsSync(candidate));
-    if (!assetPath) {
-        throw new Error(`Primitive asset not found: ${name}`);
-    }
-    return readFileSync(assetPath, "utf8");
-}
-function normalizeOfferDescriptionPayload(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return raw;
-    }
-    const payload = raw;
-    return {
-        ...payload,
-        offer_description: payload.offer_description
-            ?? payload.offerDescription
-            ?? payload.description
-            ?? payload.offer
-            ?? payload.details,
-        count: payload.count ?? payload.n ?? payload.number_of_hooks ?? payload.number_of_angles ?? payload.question_count
-    };
-}
-function normalizeAnglePayload(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return raw;
-    }
-    const payload = normalizeOfferDescriptionPayload(raw);
-    return {
-        ...payload,
-        problem_awareness: payload.problem_awareness ?? payload.problemAwareness ?? payload.problem_stage ?? payload.problemStage,
-        solution_awareness: payload.solution_awareness ?? payload.solutionAwareness ?? payload.solution_stage ?? payload.solutionStage
-    };
-}
-function normalizeColdstartPayload(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return raw;
-    }
-    const payload = raw;
-    return {
-        ...payload,
-        user_message: payload.user_message
-            ?? payload.userMessage
-            ?? payload.message
-            ?? payload.user_input
-            ?? payload.userInput
-            ?? payload.offer_description
-            ?? payload.offerDescription
-            ?? payload.description
-            ?? payload.offer
-            ?? payload.details,
-        count: payload.count ?? payload.n ?? payload.question_count
-    };
-}
-function normalizeProductPlacementPayload(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return raw;
-    }
-    const payload = normalizeOfferDescriptionPayload(raw);
-    return {
-        ...payload,
-        source_video_url: payload.source_video_url
-            ?? payload.sourceVideoUrl
-            ?? payload.video_url
-            ?? payload.videoUrl
-            ?? payload.source_url
-            ?? payload.sourceUrl
-            ?? payload.url
-    };
-}
-function preferredTextProvider(availableProviders) {
-    // Text-only priority — the audio-only elevenlabs provider is never a candidate.
-    const priority = ["openai", "gemini", "openrouter", "perplexity"];
-    return priority.find((provider) => availableProviders.includes(provider)) ?? "openai";
-}
-// Product-placement analysis needs a model that can watch video. Gemini has native video
-// understanding; OpenRouter can route to multimodal models; fall back to whatever is available.
-function preferredVideoTextProvider(availableProviders) {
-    const priority = ["gemini", "openrouter", "openai", "perplexity"];
-    return priority.find((provider) => availableProviders.includes(provider)) ?? "gemini";
-}
-async function runBrainstormText(ctx, input) {
-    const provider = input.provider ?? preferredTextProvider(ctx.providers.listAvailableProviders());
-    const model = input.model ?? defaultTextModelForProvider(provider);
-    const generated = await ctx.providers.generateText({
-        provider,
-        model,
-        prompt: input.prompt,
-        temperature: input.temperature ?? 0.7,
-        responseFormat: input.responseFormat ?? "text",
-        ...(input.attachments && input.attachments.length ? { attachments: input.attachments } : {})
-    });
-    await recordPrimitiveProviderBilling(ctx, {
-        usageCostUsd: generated.usage.costUsd,
-        providerJob: {
-            provider,
-            model,
-            usage: generated.usage
-        }
-    }, input.kind);
-    return {
-        provider,
-        model,
-        text: generated.text.trim(),
-        usage: generated.usage
-    };
-}
-async function runBrainstormJson(ctx, input) {
-    const generated = await runBrainstormText(ctx, {
-        ...input,
-        temperature: 0.35,
-        responseFormat: "json"
-    });
-    const parsed = input.resultSchema.parse(parseJsonFromModelText(generated.text));
-    return {
-        ...generated,
-        result: parsed
-    };
-}
-function parseJsonFromModelText(text) {
-    const trimmed = text.trim();
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
-        if (fenced?.[1]) {
-            return JSON.parse(fenced[1]);
-        }
-        const firstBrace = trimmed.indexOf("{");
-        const lastBrace = trimmed.lastIndexOf("}");
-        if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
-            return JSON.parse(trimmed.slice(firstBrace, lastBrace + 1));
-        }
-        throw new Error("AI returned invalid JSON for brainstorm primitive output.");
-    }
-}
-function buildHooksPrompt(offerDescription, count) {
-    return [
-        "You are Vidfarm's elite paid-social hook strategist.",
-        "Your job is to generate high-upside ad hooks for TikTok-native creative.",
-        "Bias toward hooks that feel native to TikTok, but keep raw persuasive power more important than surface trendiness.",
-        "Max creativity. Do not hold back. Be as diverse as possible while staying relevant to the offer.",
-        "Use many angle families across the set: pain, status, curiosity, gossip, confession, myth-busting, shock, taboo, mechanism, objection, identity, urgency, pattern interrupt, transformation, proof, enemy, mistake, secret, social proof, aspiration, and contrarian frames.",
-        "Each hook should be sharp, testable, and materially different from the others.",
-        `Generate exactly ${count} hooks.`,
-        "Return strict JSON only with shape {\"hooks\":[{\"hook\":\"...\",\"explanation\":\"...\"}]}.",
-        "Explanation should be 1-3 sentences on why the hook works and what angle it is leveraging.",
-        "",
-        "Offer details:",
-        offerDescription.trim(),
-        "",
-        "Reference lessons to apply:",
-        hooksReferenceText
-    ].join("\n");
-}
-function buildAwarenessStagesPrompt(offerDescription) {
-    return [
-        "You are Vidfarm's direct-response strategist.",
-        "The user is not sure what type of ads to produce.",
-        "Use Eugene Schwartz-style awareness-stage reasoning to recommend what kinds of ads to make first.",
-        "Write a practical response for TikTok-first performance marketing, but keep the advice broadly useful for paid social.",
-        "Do not return JSON. Return a clear markdown string.",
-        "Include:",
-        "- which awareness stages are most promising first",
-        "- why those stages fit this offer",
-        "- what ad types/messages belong in each stage",
-        "- what to test before moving to deeper or broader awareness stages",
-        "- a short next-step recommendation",
-        "",
-        "Offer details:",
-        offerDescription.trim(),
-        "",
-        "Reference lessons to apply:",
-        awarenessReferenceText
-    ].join("\n");
-}
-function buildAnglesPrompt(payload) {
-    return [
-        "You are Vidfarm's senior direct-response angle strategist.",
-        "Generate persuasive advertising angles for TikTok-native ads.",
-        "Persuasive depth matters more than format gimmicks. The user wants raw winning angles to test.",
-        "Do not mention templates, scenes, or production mechanics. Focus on the strategic angle itself.",
-        "Create major diversity across the set: pain, myths, enemies, mechanisms, shocking truths, confessions, gossip/social proof, objections, hidden costs, status, identity, aspiration, taboo, mistake, urgency, proof, authority, trend hijack, curiosity, and contrarian frames.",
-        "Favor known winning angle archetypes while still making them specific to the offer.",
-        `Generate exactly ${payload.count} angles.`,
-        "Return strict JSON only with shape {\"angles\":[{\"angle\":\"...\",\"explanation\":\"...\"}]}",
-        "Explanation should say why the angle fits this awareness state and what persuasive lever it uses.",
-        "",
-        `Problem awareness: ${payload.problem_awareness}`,
-        `Solution awareness: ${payload.solution_awareness}`,
-        `Derived stage note: ${describeAwarenessSelection(payload.problem_awareness, payload.solution_awareness)}`,
-        "",
-        "Offer details:",
-        payload.offer_description.trim(),
-        "",
-        "Reference lessons to apply from awareness stages:",
-        awarenessReferenceText,
-        "",
-        "Reference lessons to apply from hooks:",
-        hooksReferenceText
-    ].join("\n");
-}
-function buildColdstartPrompt(userMessage, count) {
-    return [
-        "You are Vidfarm's TikTok growth strategist.",
-        "The customer has no idea where to start.",
-        "Generate the best possible foundational Q&A questions for the customer and AI to discuss so they can build a strong TikTok strategy from zero.",
-        "The goal is to produce questions whose answers can later power awareness-stage selection, angle generation, hooks, scripts, and template choice.",
-        `Generate exactly ${count} questions.`,
-        "You must include questions covering, at minimum:",
-        "- one-line offer",
-        "- one-paragraph offer",
-        "- precise target customer psyche",
-        "- customer pain in their own words",
-        "- awareness levels or uncertainty about them",
-        "Add more strong questions beyond those when useful.",
-        "Return strict JSON only with shape {\"questions\":[{\"question\":\"...\",\"why_it_matters\":\"...\"}]}",
-        "Questions should be phrased so the user can answer them in a Google Doc or markdown file for future use.",
-        "At least one question should explicitly encourage them to save these answers for reuse inside Vidfarm.",
-        "",
-        "User message:",
-        userMessage.trim()
-    ].join("\n");
-}
-function buildProductPlacementPrompt(offerDescription, count) {
-    return [
-        "You are Vidfarm's native-advertising product-placement strategist.",
-        "You are watching the attached video. Study what is actually on screen: scenes, actions, objects, spoken lines, on-screen text, transitions, and emotional beats.",
-        "Your job is to find the highest-leverage moments to organically place the user's product into THIS video so it feels native rather than bolted on.",
-        "Bias toward placements that ride the existing attention, emotion, or story beat of the moment. Native and believable beats loud and interruptive.",
-        "Consider many placement types: on-screen prop/set dressing, character interaction with the product, verbal mention or callout, text/caption overlay, sticker or lower-third, b-roll cutaway, screen/UI replacement, before/after demo, and end-card CTA.",
-        `Identify exactly ${count} distinct product-placement opportunities, ordered from strongest to weakest.`,
-        "Each opportunity must reference a real, specific moment you actually saw in the video, with an approximate timestamp or range (for example \"0:04\" or \"0:12-0:18\").",
-        "Return strict JSON only with shape {\"opportunities\":[{\"timestamp\":\"...\",\"scene\":\"...\",\"placement_type\":\"...\",\"placement_idea\":\"...\",\"why_it_works\":\"...\"}]}.",
-        "\"scene\" briefly describes what is happening on screen at that moment. \"placement_idea\" is the concrete, actionable way to insert the product. \"why_it_works\" explains the persuasion/attention logic.",
-        "",
-        "Product / offer to place:",
-        offerDescription.trim()
-    ].join("\n");
-}
-function describeAwarenessSelection(problemAwareness, solutionAwareness) {
-    if (problemAwareness === "problem_unaware" && solutionAwareness === "solution_unaware") {
-        return "Lead with unaware-style pattern interrupts, identity, curiosity, story, and emotionally resonant entry points before surfacing the problem.";
-    }
-    if (problemAwareness === "problem_aware" && solutionAwareness === "solution_unaware") {
-        return "Lead with sharp articulation of the pain and consequences, then reveal a new possible solution path.";
-    }
-    if (problemAwareness === "problem_aware" && solutionAwareness === "solution_aware") {
-        return "Lead with strong solution-category promises, differentiation, mechanism, and proof.";
-    }
-    return "Lead with high-curiosity or identity-first entry points that bridge people from vague discomfort toward the existence of a real solution category.";
-}
-async function recordPrimitiveMediaBilling(ctx, input) {
-    if (!Number.isFinite(input.costUsd) || input.costUsd <= 0) {
-        return;
-    }
-    await ctx.billing.record({
-        type: "cpu_estimate",
-        costUsd: input.costUsd,
-        costCenterSlug: input.costCenterSlug,
-        idempotencyKey: input.idempotencyKey,
-        occurredAtMs: Date.now(),
-        metadata: input.metadata
-    });
-}
-async function executePrimitiveMediaOperation(ctx, input) {
-    const execution = await primitiveMediaService.execute({
-        operation: input.operation,
-        payload: input.payload,
-        outputKey: ctx.storage.resolveKey(input.outputKey),
-        localOutputKey: input.outputKey,
-        storeLocal: async (key, bytes, contentType) => ctx.storage.putBuffer(key, bytes, {
-            contentType,
-            kind: contentType.startsWith("audio/") ? "audio" : contentType.startsWith("image/") ? "image" : "video",
-            metadata: {
-                primitive_media_operation: input.operation
-            }
-        })
-    });
-    await recordPrimitiveMediaBilling(ctx, {
-        costUsd: execution.billingCostUsd,
-        costCenterSlug: execution.billingCostCenterSlug,
-        idempotencyKey: `${execution.billingCostCenterSlug}:${ctx.customer.id}:${input.operation}:${execution.storageKey}`,
-        metadata: {
-            ...execution.billingMetadata,
-            output_key: execution.storageKey
-        }
-    });
-    return execution;
-}
-function inferMediaType(mediaUrl) {
-    return /\.(mp4|mov|webm|m4v)(\?|#|$)/i.test(mediaUrl) ? "video" : "image";
-}
-function compactUrls(values) {
-    return values.filter((value) => Boolean(value));
-}
-function isVidfarmControlPlaneArtifactUrl(value) {
-    try {
-        const url = new URL(value);
-        return /\/api\/v1\/(?:user\/me|templates\/[^/]+|primitives(?:\/[^/]+)?)\/jobs\/[^/]+\/artifacts\/?$/u.test(url.pathname);
-    }
-    catch {
-        return false;
-    }
-}
-function selectDownloadedVideoMediaCandidate(medias, qualityPreference) {
-    const playable = medias.filter((media) => typeof media.url === "string"
-        && media.url.length > 0
-        && media.videoAvailable !== false
-        && (media.extension?.toLowerCase() === "mp4" || /\.mp4(\?|#|$)/i.test(media.url)));
-    if (!playable.length)
-        return null;
-    const preferredRank = qualityPreference === "full_hd"
-        ? ["full hd", "hd", "best", ""]
-        : qualityPreference === "hd"
-            ? ["hd", "full hd", "best", ""]
-            : ["full hd", "hd", "best", ""];
-    const sorted = playable.slice().sort((left, right) => {
-        const leftRank = preferredRank.indexOf(normalizeDownloadedVideoQuality(left.quality));
-        const rightRank = preferredRank.indexOf(normalizeDownloadedVideoQuality(right.quality));
-        const normalizedLeftRank = leftRank === -1 ? preferredRank.length : leftRank;
-        const normalizedRightRank = rightRank === -1 ? preferredRank.length : rightRank;
-        if (normalizedLeftRank !== normalizedRightRank)
-            return normalizedLeftRank - normalizedRightRank;
-        return (right.size ?? 0) - (left.size ?? 0);
-    });
-    return sorted[0] ?? null;
-}
-function normalizeDownloadedVideoQuality(value) {
-    return String(value ?? "").trim().toLowerCase().replace(/_/g, " ");
-}
-async function fetchRemoteBinary(url, fallbackContentType) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Unable to download remote media: HTTP ${response.status}`);
-    }
-    const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() || fallbackContentType;
-    return {
-        bytes: Buffer.from(await response.arrayBuffer()),
-        contentType
-    };
-}
-function normalizeVideoContentType(contentType) {
-    const normalized = contentType.toLowerCase();
-    if (normalized === "video/quicktime")
-        return "video/quicktime";
-    if (normalized === "video/webm")
-        return "video/webm";
-    return "video/mp4";
-}
-function videoExtensionForContentType(contentType) {
-    if (contentType === "video/quicktime")
-        return "mov";
-    if (contentType === "video/webm")
-        return "webm";
-    return "mp4";
-}
-function safeUrlHost(value) {
-    try {
-        return new URL(value).host;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=primitive-registry.js.map