@mevdragon/vidfarm-devcli 0.5.3 → 0.7.0

package/dist/src/primitive-registry.js

@@ -0,0 +1,2561 @@
+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 { 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")
+}));
+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 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)
+}));
+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_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_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 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 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
+                }
+            });
+            const manifest = {
+                primitive: "video_download",
+                operation: "download-video",
+                sourceUrl,
+                sourceHost,
+                title: lookup.title ?? null,
+                thumbnail: 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
+            });
+            return {
+                progress: 1,
+                output: {
+                    files: compactUrls([storedVideo.url, manifestArtifact?.url]),
+                    sourceUrl,
+                    sourceHost,
+                    videoUrl: storedVideo.url,
+                    sourceVideoUrl: storedVideo.url,
+                    primary_file_url: storedVideo.url,
+                    title: lookup.title ?? null,
+                    thumbnail: lookup.thumbnail ?? null,
+                    duration: lookup.duration ?? null,
+                    selectedMediaUrl: selectedMedia.url,
+                    manifest: manifestArtifact
+                }
+            };
+        }
+    }
+});
+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;
+            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 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],
+        [videoGeneratePrimitive.id, videoGeneratePrimitive],
+        [videoRenderSlidesPrimitive.id, videoRenderSlidesPrimitive],
+        [mediaDedupePrimitive.id, mediaDedupePrimitive],
+        [videoNormalizePrimitive.id, videoNormalizePrimitive],
+        [videoDownloadPrimitive.id, videoDownloadPrimitive],
+        [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],
+        [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";
+    }
+}
+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"
+    };
+}
+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) {
+    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