@mevdragon/vidfarm-devcli 0.2.12 → 0.2.14

package/templates/vidfarm_template_0000/src/template.js

@@ -0,0 +1,1566 @@
+import { z } from "zod";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as fontkit from "fontkit";
+import sharp from "sharp";
+import { normalizeToPortraitFrame } from "./lib/images.js";
+import { defineTemplate, } from "./sdk.js";
+import { TEMPLATE_FONT_IDS, TEMPLATE_FONT_OPTIONS, TEMPLATE_TEXT_BACKGROUND_COLOR_IDS, TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS, } from "./style-options.js";
+import { templateLinkToOriginal, templateVisualDna, templateViralDna } from "./template-dna.js";
+const TEMPLATE_ID = "4c7a7e1a-7f35-4f30-9f86-9c8a63c7f2db";
+const TEMPLATE_SLUG_ID = "template_0000";
+const COMPOSITION_ID = "template-0000";
+const TEMPLATE_PREVIEW_MEDIA = [
+    "templates/template-0000/about/preview-01.jpg",
+];
+const FRAME = { width: 1080, height: 1920 };
+const TIKTOK_SAFE_AREA = {
+    left: 78,
+    right: 248,
+    top: 196,
+    bottom: 408,
+};
+const NATIVE_UI_TEXT_ZONE = {
+    minCenterXPercent: 0.38,
+    maxCenterXPercent: 0.62,
+    minCenterYPercent: 0.2,
+    maxCenterYPercent: 0.58,
+};
+const TEXT_BACKGROUND_NONE = "none";
+const CUSTOM_CAPTION_FONT_ID = "custom";
+const CUSTOM_TEXT_BACKGROUND_ID = "custom";
+const TEXT_CHIP_PADDING_X = 20;
+const TEXT_CHIP_PADDING_Y = 12;
+const TEXT_CHIP_RADIUS = 12;
+const TEXT_CHIP_OPACITY = 0.86;
+const NATIVE_SHADOW_PADDING = 28;
+const NATIVE_SHADOW_BLURS = [1.6, 4.8];
+// Documentation-only dependency map for humans and agents.
+// The current template standard has no first-class dependencies field, so
+// provider/model requirements must be declared in source and SKILL.md.
+const TEMPLATE_PROVIDER_REQUIREMENTS = {
+    image: [
+        { provider: "openai", models: ["gpt-image-1", "gpt-image-2"], strict: false },
+        { provider: "gemini", models: ["gemini-3.1-flash-image-preview", "gemini-2.5-flash-image"], strict: false },
+        { provider: "openrouter", models: ["bytedance/seedance-2.0", "bytedance-seed/seedream-4.5"], strict: false, planned: true },
+    ],
+    text: [
+        { provider: "openai", models: ["gpt-5.4"], strict: false },
+        { provider: "gemini", models: ["gemini-3.1-flash-lite", "gemini-2.5-flash-lite"], strict: false },
+        { provider: "openrouter", models: ["qwen/qwen3.6-flash"], strict: false },
+    ],
+    layout_analysis: [
+        { provider: "openai", models: ["gpt-5.4"], strict: false },
+        { provider: "gemini", models: ["gemini-3.1-flash-lite", "gemini-2.5-flash-lite"], strict: false },
+        { provider: "openrouter", models: ["qwen/qwen3.6-flash"], strict: false },
+    ],
+    video: [
+        { provider: "openai", models: ["sora-2"], strict: false, planned: true },
+        { provider: "gemini", models: ["veo-3.0-generate-001"], strict: false, planned: true },
+    ],
+};
+void TEMPLATE_PROVIDER_REQUIREMENTS;
+const legacySlideInputSchema = z.union([
+    z.tuple([z.string().min(3), z.string().min(1)]),
+    z.tuple([
+        z.string().min(3),
+        z.string().min(1),
+        z.number().int().min(500).max(30000),
+    ]),
+]);
+const structuredSlideInputSchema = z.object({
+    image_prompt: z.string().min(3),
+    image_prompt_attachments: z.array(z.string().url()).max(12).default([]),
+    caption: z.string().min(1),
+    duration_ms: z.number().int().min(500).max(30000).default(4000),
+});
+const slideInputSchema = z.union([
+    legacySlideInputSchema,
+    structuredSlideInputSchema,
+]);
+const createSlideshowInputSchema = z.object({
+    slides: z.array(slideInputSchema).min(1).max(20),
+    meta_details_prompt: z.string().min(8).max(4000).optional(),
+});
+const renderSlideSchema = z.object({
+    imageUrl: z.string().url(),
+    durationMs: z.number().int().min(500).max(30000),
+});
+const renderVideoInputSchema = z.object({
+    slides: z.array(renderSlideSchema).min(1).max(20),
+});
+const supportedImageProviders = ["openai", "gemini", "openrouter"];
+const remotionEntryPoint = resolveRemotionEntryPoint();
+const templateRuntimeConfig = resolveTemplateRuntimeConfig();
+const remotionRuntimeConfig = {
+    serveUrl: templateRuntimeConfig.remotion?.serve_url ?? undefined,
+};
+const skillPath = resolveSkillPath();
+const overlayFonts = resolveOverlayFonts();
+const parsedFontCache = new Map();
+export const template0000Definition = defineTemplate({
+    id: TEMPLATE_ID,
+    slugId: TEMPLATE_SLUG_ID,
+    version: "1.0.0",
+    about: {
+        title: "Template 0000",
+        description: "Starter TikTok-safe slideshow template with staged image generation, text compositing, and optional Remotion video rendering.",
+        difficulty: "easy",
+        viral_dna: templateViralDna,
+        visual_dna: templateVisualDna,
+        preview_media: [...TEMPLATE_PREVIEW_MEDIA],
+        link_to_original: templateLinkToOriginal,
+        links_to_inspiration: templateLinkToOriginal ? [templateLinkToOriginal] : [],
+        sound: {
+            sound_title: "original sound",
+            sound_url: ""
+        },
+        proposal_generator: "Given the director's product, customer, and angle, propose multiple slideshow concepts that fit this template's creator-native TikTok format. Return concrete post ideas that can either be used directly as single prompts or expanded into 10+ related prompts. Favor specific hooks, clear educational angles, founder stories, product proof, objections, comparisons, and repeatable series ideas.",
+        skeleton_prompt: "Create a [number]-slide TikTok slideshow for [audience] about [topic/product/angle]. Slide 1 hook: [hook]. Middle slides: [proof, explanation, story beat, comparison, or objection handling]. Final slide CTA or takeaway: [ending]. For each slide include exact overlay text plus a matching visual prompt. Tone: [creator-native / direct / educational / punchy].",
+        sample_prompts: [
+            "Make a 3-slide TikTok slideshow explaining why cold plunges feel so hard at first but get easier after a week. Use exact overlay text for each slide and generate matching cinematic background prompts.",
+            "Create a founder-story slideshow about launching a niche coffee brand, with one hook slide, one proof slide, and one CTA slide. Keep the tone creator-native and direct.",
+            "Build a product explainer slideshow for a posture-correcting desk setup. I want concise overlays, clean visual prompts, and output ready for optional Remotion rendering."
+        ],
+    },
+    examples: [],
+    skillPath,
+    configSchema: z.object({
+        defaultProvider: z.enum(supportedImageProviders).default("gemini"),
+        textModel: z.string().optional(),
+        imageModel: z.string().optional(),
+        captionFont: z.enum([...TEMPLATE_FONT_IDS, CUSTOM_CAPTION_FONT_ID]).default("tiktok_sans_semibold"),
+        captionBackgroundColor: z
+            .enum([TEXT_BACKGROUND_NONE, ...TEMPLATE_TEXT_BACKGROUND_COLOR_IDS])
+            .default(TEXT_BACKGROUND_NONE),
+        customCaptionFontFamily: z.string().min(1).max(128).optional(),
+        customCaptionFontWeight: z.number().int().min(100).max(900).optional(),
+        customCaptionFontAssetPath: z.string().min(1).max(512).optional(),
+        customCaptionTextColorHex: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+        customCaptionBackgroundColorHex: z.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+        renderCompositionId: z.string().default(COMPOSITION_ID),
+    }),
+    operations: {
+        create_slideshow: {
+            description: "Generate TikTok-safe 9:16 background images, composite the exact overlay text into finished slide frames, and save a manifest.",
+            inputSchema: createSlideshowInputSchema,
+            workflow: "createSlideshowWorkflow",
+            webhookSupport: true,
+            smokeTestPayload: {
+                slides: [
+                    ["a founder at a desk", "Launch faster", 2400],
+                    {
+                        image_prompt: "close-up product photo",
+                        image_prompt_attachments: [
+                            "https://images.unsplash.com/photo-1520607162513-77705c0f0d4a?auto=format&fit=crop&w=1080&q=80",
+                        ],
+                        caption: "Built in-house",
+                        duration_ms: 3200,
+                    },
+                ],
+                meta_details_prompt: "Target US TikTok skincare and startup audiences. Make the hook curiosity-driven, natural, and UGC-native.",
+            },
+        },
+        render_video: {
+            description: "Turn finished slideshow frames into an auto-advancing vertical video using Remotion.",
+            inputSchema: renderVideoInputSchema,
+            workflow: "renderVideoWorkflow",
+            webhookSupport: true,
+            smokeTestPayload: {
+                slides: [
+                    {
+                        imageUrl: "https://images.unsplash.com/photo-1519389950473-47ba0277781c?auto=format&fit=crop&w=1080&q=80",
+                        durationMs: 2400,
+                    },
+                    {
+                        imageUrl: "https://images.unsplash.com/photo-1520607162513-77705c0f0d4a?auto=format&fit=crop&w=1080&q=80",
+                        durationMs: 3200,
+                    },
+                ],
+            },
+        },
+    },
+    jobs: {
+        async createSlideshowWorkflow(ctx, input) {
+            const payload = createSlideshowInputSchema.parse(input);
+            ctx.logger.progress(0.04, "Starting template_0000 slideshow image stage");
+            const provider = parseImageProvider(ctx.templateConfig.defaultProvider);
+            const configuredTextModel = typeof ctx.templateConfig.textModel === "string"
+                ? ctx.templateConfig.textModel
+                : null;
+            const configuredImageModel = typeof ctx.templateConfig.imageModel === "string"
+                ? ctx.templateConfig.imageModel
+                : null;
+            const textModel = String(configuredTextModel ?? defaultTextModelForProvider(provider));
+            const imageModel = String(configuredImageModel ?? defaultImageModelForProvider(provider));
+            const textStyle = resolveTextStyleSpec(ctx.templateConfig);
+            const slides = [];
+            for (const [index, rawSlide] of payload.slides.entries()) {
+                const { sourceType, sourceValue, imagePrompt, imagePromptAttachments, overlayText, durationMs, } = normalizeSlideInput(rawSlide);
+                ctx.logger.progress(0.08 + (index / payload.slides.length) * 0.42, sourceType === "image_source"
+                    ? `Loading slide ${index + 1} source image`
+                    : `Generating slide ${index + 1} image`);
+                const image = sourceType === "image_source"
+                    ? await loadExistingSlideImage(sourceValue)
+                    : await generatePortraitCandidateImage(ctx, {
+                        provider,
+                        imageModel,
+                        configuredProvider: provider,
+                        configuredImageModel,
+                        imagePrompt,
+                        imagePromptAttachments,
+                        overlayText,
+                    });
+                if (sourceType === "ai_prompt") {
+                    await ctx.billing.record({
+                        type: "ai_generation",
+                        costUsd: 0.04,
+                        metadata: {
+                            stage: "image_generation",
+                            slideIndex: index,
+                            model: imageModel,
+                        },
+                    });
+                }
+                ctx.logger.progress(0.13 + (index / payload.slides.length) * 0.3, `Normalizing slide ${index + 1} to strict 9:16 portrait`);
+                const normalizedImage = await normalizeToPortraitFrame(image.bytes, FRAME);
+                const backgroundArtifact = await ctx.storage.putBuffer(`backgrounds/slide-${pad2(index + 1)}.png`, normalizedImage.bytes, {
+                    contentType: normalizedImage.contentType,
+                    kind: "image",
+                    metadata: {
+                        slideIndex: index,
+                        prompt: image.prompt,
+                        revisedPrompt: image.revisedPrompt,
+                        width: normalizedImage.width,
+                        height: normalizedImage.height,
+                        aspectRatio: "9:16",
+                    },
+                });
+                ctx.logger.progress(0.18 + (index / payload.slides.length) * 0.28, `Scoring TikTok-safe text layout for slide ${index + 1}`);
+                const layout = await chooseSlideLayout(ctx, {
+                    provider,
+                    model: textModel,
+                    imageBytes: normalizedImage.bytes,
+                    imageUrl: backgroundArtifact.url,
+                    overlayText,
+                });
+                ctx.logger.progress(0.24 + (index / payload.slides.length) * 0.28, `Compositing caption into slide ${index + 1}`);
+                const frameBytes = await renderFinishedSlide(normalizedImage.bytes, overlayText, layout, textStyle);
+                const frameArtifact = await ctx.storage.putBuffer(`slides/slide-${pad2(index + 1)}.png`, frameBytes, {
+                    contentType: "image/png",
+                    kind: "image",
+                    metadata: {
+                        slideIndex: index,
+                        overlayText,
+                        layout,
+                        aspectRatio: "9:16",
+                        kind: "finished_slide_frame",
+                    },
+                });
+                slides.push({
+                    index,
+                    sourceType,
+                    sourceValue,
+                    imagePrompt,
+                    imagePromptAttachments,
+                    overlayText,
+                    durationMs,
+                    backgroundImageUrl: backgroundArtifact.url,
+                    frameImageUrl: frameArtifact.url,
+                    prompt: image.prompt,
+                    revisedPrompt: image.revisedPrompt,
+                    layout,
+                });
+            }
+            ctx.logger.progress(0.72, "Generating post metadata");
+            const metaDetails = await generateMetaDetails(ctx, {
+                provider,
+                textModel,
+                configuredProvider: provider,
+                configuredTextModel,
+                slides,
+                metaDetailsPrompt: payload.meta_details_prompt,
+            });
+            await ctx.billing.record({
+                type: "ai_generation",
+                costUsd: 0.01,
+                metadata: { stage: "meta_details_generation", model: textModel },
+            });
+            ctx.logger.progress(0.78, "Saving slideshow manifest");
+            const manifest = {
+                templateId: TEMPLATE_ID,
+                size: { width: FRAME.width, height: FRAME.height, aspectRatio: "9:16" },
+                textStyle: {
+                    fontId: textStyle.fontId,
+                    fontFamily: textStyle.fontFamily,
+                    fontWeight: textStyle.fontWeight,
+                    fill: textStyle.fill,
+                    backgroundColorId: textStyle.backgroundColorId,
+                    backgroundColorHex: textStyle.backgroundColorHex,
+                    shadow: "soft native TikTok-style black drop shadow",
+                    availableFonts: TEMPLATE_FONT_OPTIONS,
+                    availableBackgroundColors: TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS,
+                },
+                safeArea: TIKTOK_SAFE_AREA,
+                metaDetails,
+                slides,
+            };
+            const manifestArtifact = await ctx.storage.putJson(`manifests/${TEMPLATE_ID}.json`, manifest);
+            const files = slides
+                .flatMap((slide) => [slide.backgroundImageUrl, slide.frameImageUrl])
+                .filter((value) => Boolean(value));
+            if (manifestArtifact.url) {
+                files.push(manifestArtifact.url);
+            }
+            ctx.logger.progress(1, "Slideshow images complete", {
+                fileCount: files.length,
+            });
+            return {
+                progress: 1,
+                output: {
+                    files,
+                    manifest: manifestArtifact,
+                    ...metaDetails,
+                    metaDetails,
+                    metaDetailsInput: {
+                        meta_details_prompt: payload.meta_details_prompt ?? null,
+                        slides: slides.map((slide) => ({
+                            index: slide.index,
+                            sourceType: slide.sourceType,
+                            sourceValue: slide.sourceValue,
+                            imagePrompt: slide.imagePrompt,
+                            imagePromptAttachments: slide.imagePromptAttachments,
+                            overlayText: slide.overlayText,
+                            durationMs: slide.durationMs,
+                        })),
+                    },
+                    renderVideoInput: {
+                        slides: slides
+                            .map((slide) => slide.frameImageUrl
+                            ? {
+                                imageUrl: slide.frameImageUrl,
+                                durationMs: slide.durationMs,
+                            }
+                            : null)
+                            .filter((slide) => Boolean(slide)),
+                    },
+                    slides,
+                },
+            };
+        },
+        async renderVideoWorkflow(ctx, input) {
+            const payload = renderVideoInputSchema.parse(input);
+            const compositionId = String(ctx.templateConfig.renderCompositionId ?? COMPOSITION_ID);
+            ctx.logger.progress(0.08, "Preparing slideshow frames for video render");
+            const slides = await resolveSlidesForRender(payload);
+            ctx.logger.progress(0.56, "Submitting Remotion render");
+            const render = await ctx.remotion.render({
+                compositionId,
+                serveUrl: remotionRuntimeConfig.serveUrl,
+                entryPoint: remotionEntryPoint,
+                outputKey: "renders/final.mp4",
+                fps: 30,
+                inputProps: {
+                    slides,
+                    fps: 30,
+                },
+            });
+            const files = slides.map((slide) => slide.imageUrl);
+            if (render.outputUrl) {
+                files.push(render.outputUrl);
+            }
+            ctx.logger.progress(1, "Slideshow video complete", {
+                fileCount: files.length,
+                renderId: render.renderId,
+            });
+            return {
+                progress: 1,
+                output: {
+                    files,
+                    render,
+                    slides,
+                },
+            };
+        },
+    },
+});
+const IMAGE_PROMPT_SYSTEM_WRAPPER = [
+    "Create an exact 9:16 portrait slideshow image for a TikTok-style vertical video.",
+    "The composition must be designed for strict full-frame mobile portrait output at 1080x1920.",
+    "Hold the camera vertically. The generated image itself must be tall portrait, not a landscape image placed inside a vertical canvas.",
+    "Return only the background scene or subject image. This is not a phone screenshot, social app mockup, or UI composition.",
+    "Do not produce square, landscape, or loose portrait framing.",
+    "Do not letterbox, pillarbox, add borders, or leave empty margins.",
+    "Crop tighter if needed so the frame reads as a native vertical shot. Avoid fake poster framing, inset postcards, or giant blank padding.",
+    "Do not sacrifice the vertical composition just to keep the entire subject visible.",
+    "Leave less important negative space near the top edge, right edge, and lower portion of the frame so later video overlays can sit there without covering the subject.",
+    "Keep the right edge visually quieter and avoid placing important details there.",
+    "Keep the top edge visually quieter and avoid placing important details there.",
+    "Keep the lower portion visually quieter and avoid placing important details there.",
+    "Reserve one clean editorial text lane in the upper-left or center-left portion of the frame for the overlay.",
+    "That reserved lane is empty space only. Do not render the overlay or any placeholder text.",
+    "Do not render any phone UI, social media UI, app chrome, search bars, tabs, buttons, likes, comments, avatars, battery icons, status bars, frames, stickers, or interface elements.",
+    "Do not render any words, letters, captions, subtitles, titles, logos, signage, labels, watermarks, or typography inside the image.",
+    "The final image must contain zero visible text unless part of the scene itself.",
+    "Use cinematic lighting, crisp detail, and framing that already fits an exact 9:16 portrait frame, unless otherwise specified.",
+    "Avoid giant blank ceiling, wall, floor, or sky bands that make the frame feel padded or zoomed out.",
+].join("\n");
+function buildImagePrompt(imagePrompt, overlayText, imagePromptAttachments = []) {
+    return [
+        IMAGE_PROMPT_SYSTEM_WRAPPER,
+        `User visual prompt: ${imagePrompt}`,
+        ...(imagePromptAttachments.length
+            ? [
+                `Use the attached reference media as visual guidance for subject matter, style, composition, or product details, but still return one fresh final image.`,
+            ]
+            : []),
+        `Reserve room for a short editorial overlay approximately ${overlayText.length} characters long, but do not render the overlay text itself.`,
+    ].join("\n");
+}
+async function generatePortraitCandidateImage(ctx, input) {
+    const attempts = [
+        buildImagePrompt(input.imagePrompt, input.overlayText, input.imagePromptAttachments),
+        [
+            buildImagePrompt(input.imagePrompt, input.overlayText, input.imagePromptAttachments),
+            "Critical correction: the previous output risked being too wide.",
+            "Return a true full-frame mobile portrait composition.",
+            "Do not create a landscape scene floating inside a vertical canvas.",
+            "The subject and horizon should already be composed for 9:16 viewing.",
+            "Tighter framing is preferred over wide empty margins.",
+        ].join("\n"),
+        [
+            buildImagePrompt(input.imagePrompt, input.overlayText, input.imagePromptAttachments),
+            "Critical correction: return an unmistakably vertical composition.",
+            "Push the camera closer if needed so the frame reads as native 9:16 portrait.",
+            "No inset landscape window, no postcard composition, no wide aerial framing.",
+            "Use a clean magazine-style composition with one obvious text lane.",
+        ].join("\n"),
+        [
+            buildImagePrompt(input.imagePrompt, input.overlayText, input.imagePromptAttachments),
+            "Critical correction: the previous output likely had empty padding or weak mobile framing.",
+            "Fill the frame with a real handheld-phone portrait composition.",
+            "No white bars, no blank top or bottom bands, and no subject floating in the middle of excess space.",
+            "Crop decisively and favor a native social-video camera distance.",
+        ].join("\n"),
+    ];
+    let best = null;
+    let lastError = null;
+    for (const provider of providerFailoverOrder(input.provider)) {
+        const imageModel = resolveImageModelForAttempt(provider, input.configuredProvider, input.configuredImageModel);
+        try {
+            for (const prompt of attempts) {
+                const image = await ctx.providers.generateImage({
+                    provider,
+                    model: imageModel,
+                    prompt,
+                    promptAttachments: input.imagePromptAttachments,
+                    size: sourceImageSizeForProvider(provider),
+                    aspectRatio: "9:16",
+                    imageSize: sourceImageOutputSizeForProvider(provider, imageModel),
+                });
+                const score = await portraitScore(image.bytes);
+                if (!best || score < best.score) {
+                    best = { ...image, prompt, score };
+                }
+                if (score <= 0.16) {
+                    return best;
+                }
+            }
+            if (best) {
+                return best;
+            }
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            ctx.logger.warn("Image generation provider failed, trying next provider", {
+                provider,
+                model: imageModel,
+                message: lastError.message,
+            });
+        }
+    }
+    if (!best) {
+        throw lastError ?? new Error("No image candidate was generated.");
+    }
+    return best;
+}
+function defaultLayout() {
+    return {
+        zone: "center",
+        align: "center",
+        maxWidthPercent: 58,
+        anchorXPercent: 0.5,
+        anchorYPercent: 0.28,
+        justification: "Default placement uses a centered TikTok-native text zone in the middle third of the safe frame.",
+    };
+}
+function parseImageProvider(value) {
+    if (typeof value === "string" && isImageProvider(value)) {
+        return value;
+    }
+    return "gemini";
+}
+function isImageProvider(value) {
+    return (typeof value === "string" &&
+        supportedImageProviders.includes(value));
+}
+function sourceImageSizeForProvider(provider) {
+    if (provider === "openai") {
+        return "1024x1536";
+    }
+    return "1080x1920";
+}
+function defaultImageModelForProvider(provider) {
+    if (provider === "openai") {
+        return "gpt-image-1";
+    }
+    if (provider === "openrouter") {
+        return "bytedance-seed/seedream-4.5";
+    }
+    return "gemini-2.5-flash-image";
+}
+function defaultTextModelForProvider(provider) {
+    if (provider === "openai") {
+        return "gpt-4.1-mini";
+    }
+    if (provider === "openrouter") {
+        return "openai/gpt-4.1-mini";
+    }
+    return "gemini-3.1-flash-lite";
+}
+function sourceImageOutputSizeForProvider(provider, model) {
+    if (provider === "openrouter") {
+        return "2K";
+    }
+    if (provider !== "gemini") {
+        return undefined;
+    }
+    if (model === "gemini-3-pro-image-preview") {
+        return "1K";
+    }
+    return undefined;
+}
+function providerFailoverOrder(primary) {
+    return [
+        primary,
+        ...supportedImageProviders.filter((provider) => provider !== primary),
+    ];
+}
+function resolveImageModelForAttempt(provider, configuredProvider, configuredImageModel) {
+    if (provider === configuredProvider && configuredImageModel) {
+        return configuredImageModel;
+    }
+    return defaultImageModelForProvider(provider);
+}
+function resolveTextModelForAttempt(provider, configuredProvider, configuredTextModel) {
+    if (provider === configuredProvider && configuredTextModel) {
+        return configuredTextModel;
+    }
+    return defaultTextModelForProvider(provider);
+}
+function resolveTextStyleSpec(config) {
+    const fontId = config.captionFont === CUSTOM_CAPTION_FONT_ID
+        ? CUSTOM_CAPTION_FONT_ID
+        : isTemplateFontId(config.captionFont)
+            ? config.captionFont
+            : "tiktok_sans_semibold";
+    const backgroundColorId = typeof config.customCaptionBackgroundColorHex === "string"
+        ? CUSTOM_TEXT_BACKGROUND_ID
+        : config.captionBackgroundColor === TEXT_BACKGROUND_NONE ||
+            isTemplateBackgroundColorId(config.captionBackgroundColor)
+            ? config.captionBackgroundColor
+            : TEXT_BACKGROUND_NONE;
+    const fontOption = fontId === CUSTOM_CAPTION_FONT_ID
+        ? null
+        : (TEMPLATE_FONT_OPTIONS.find((option) => option.id === fontId) ??
+            TEMPLATE_FONT_OPTIONS[0]);
+    const backgroundOption = backgroundColorId &&
+        backgroundColorId !== TEXT_BACKGROUND_NONE &&
+        backgroundColorId !== CUSTOM_TEXT_BACKGROUND_ID
+        ? (TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS.find((option) => option.id === backgroundColorId) ?? null)
+        : null;
+    const customFontPath = fontId === CUSTOM_CAPTION_FONT_ID &&
+        typeof config.customCaptionFontAssetPath === "string"
+        ? resolveCustomCaptionFontPath(config.customCaptionFontAssetPath)
+        : null;
+    const resolvedFontOption = fontOption ?? TEMPLATE_FONT_OPTIONS[0];
+    return {
+        fontId,
+        fontFamily: fontId === CUSTOM_CAPTION_FONT_ID &&
+            typeof config.customCaptionFontFamily === "string"
+            ? config.customCaptionFontFamily
+            : resolvedFontOption.family,
+        fontWeight: fontId === CUSTOM_CAPTION_FONT_ID &&
+            typeof config.customCaptionFontWeight === "number"
+            ? config.customCaptionFontWeight
+            : resolvedFontOption.weight,
+        fontPath: fontId === CUSTOM_CAPTION_FONT_ID
+            ? customFontPath
+            : overlayFonts[resolvedFontOption.id].path,
+        fill: typeof config.customCaptionTextColorHex === "string"
+            ? config.customCaptionTextColorHex
+            : "#ffffff",
+        backgroundColorId: backgroundColorId ?? TEXT_BACKGROUND_NONE,
+        backgroundColorHex: backgroundColorId === CUSTOM_TEXT_BACKGROUND_ID &&
+            typeof config.customCaptionBackgroundColorHex === "string"
+            ? config.customCaptionBackgroundColorHex
+            : backgroundOption?.hex ?? null,
+    };
+}
+function isTemplateFontId(value) {
+    return (typeof value === "string" &&
+        TEMPLATE_FONT_IDS.includes(value));
+}
+function isTemplateBackgroundColorId(value) {
+    return (typeof value === "string" &&
+        TEMPLATE_TEXT_BACKGROUND_COLOR_IDS.includes(value));
+}
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}
+async function resolveSlidesForRender(input) {
+    return input.slides;
+}
+const slideshowManifestSchema = z.object({
+    templateId: z.string(),
+    size: z.object({
+        width: z.number(),
+        height: z.number(),
+        aspectRatio: z.literal("9:16"),
+    }),
+    textStyle: z.object({
+        fontId: z.enum([...TEMPLATE_FONT_IDS, CUSTOM_CAPTION_FONT_ID]),
+        fontFamily: z.string(),
+        fontWeight: z.number(),
+        fill: z.string(),
+        backgroundColorId: z.enum([
+            TEXT_BACKGROUND_NONE,
+            CUSTOM_TEXT_BACKGROUND_ID,
+            ...TEMPLATE_TEXT_BACKGROUND_COLOR_IDS,
+        ]),
+        backgroundColorHex: z.string().nullable(),
+        shadow: z.string(),
+        availableFonts: z.array(z.object({
+            id: z.enum(TEMPLATE_FONT_IDS),
+            label: z.string(),
+            family: z.string(),
+            weight: z.number(),
+            assetFile: z.string().optional(),
+            fontsourceFile: z.string().optional(),
+            source: z.string(),
+            role: z.string(),
+            aliasOf: z.string().optional(),
+        })),
+        availableBackgroundColors: z.array(z.object({
+            id: z.enum(TEMPLATE_TEXT_BACKGROUND_COLOR_IDS),
+            label: z.string(),
+            hex: z.string(),
+        })),
+    }),
+    safeArea: z.object({
+        left: z.number(),
+        right: z.number(),
+        top: z.number(),
+        bottom: z.number(),
+    }),
+    metaDetails: z.object({
+        title: z.string(),
+        description: z.string(),
+        pinned_comment: z.string(),
+        location: z.string(),
+        song: z.string(),
+    }),
+    slides: z.array(z.object({
+        index: z.number(),
+        sourceType: z.enum(["ai_prompt", "image_source"]),
+        sourceValue: z.string(),
+        imagePrompt: z.string(),
+        imagePromptAttachments: z.array(z.string().url()),
+        overlayText: z.string(),
+        durationMs: z.number().int(),
+        backgroundImageUrl: z.string().url().nullable(),
+        frameImageUrl: z.string().url().nullable(),
+        prompt: z.string(),
+        revisedPrompt: z.string().nullable(),
+        layout: z.object({
+            zone: z.enum(["top", "center", "bottom"]),
+            align: z.enum(["left", "center", "right"]),
+            maxWidthPercent: z.number(),
+            anchorXPercent: z.number().optional(),
+            anchorYPercent: z.number().optional(),
+            justification: z.string(),
+        }),
+    })),
+});
+function normalizeSlideInput(input) {
+    if (Array.isArray(input)) {
+        return normalizeSlideFields({
+            primarySource: input[0],
+            imagePromptAttachments: [],
+            overlayText: input[1],
+            durationMs: input[2] ?? 4000,
+        });
+    }
+    return normalizeSlideFields({
+        primarySource: input.image_prompt,
+        imagePromptAttachments: input.image_prompt_attachments,
+        overlayText: input.caption,
+        durationMs: input.duration_ms,
+    });
+}
+function normalizeSlideFields(input) {
+    const sourceValue = input.primarySource.trim();
+    const existingImageSource = resolveExistingImageSource(sourceValue);
+    return {
+        sourceType: existingImageSource ? "image_source" : "ai_prompt",
+        sourceValue: existingImageSource ?? sourceValue,
+        imagePrompt: sourceValue,
+        imagePromptAttachments: input.imagePromptAttachments,
+        overlayText: input.overlayText,
+        durationMs: input.durationMs,
+    };
+}
+async function loadExistingSlideImage(sourceValue) {
+    const resolved = resolveExistingImageSource(sourceValue);
+    if (!resolved) {
+        throw new Error(`Slide source is not a supported image URL or file path: ${sourceValue}`);
+    }
+    const bytes = isLocalFileSource(resolved)
+        ? readFileSync(resolveLocalFileSourcePath(resolved))
+        : await fetchExternalImageBytes(resolved);
+    const contentType = await detectImageContentType(bytes);
+    return {
+        bytes,
+        contentType,
+        revisedPrompt: null,
+        prompt: sourceValue,
+    };
+}
+function resolveExistingImageSource(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const parsedUrl = parseUrl(trimmed);
+    if (parsedUrl &&
+        ["http:", "https:", "file:", "data:"].includes(parsedUrl.protocol)) {
+        return trimmed;
+    }
+    const localPath = resolveLocalPathIfPresent(trimmed);
+    if (localPath) {
+        return localPath;
+    }
+    return null;
+}
+function parseUrl(value) {
+    try {
+        return new URL(value);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveLocalPathIfPresent(value) {
+    const expandedPath = value.startsWith("~/")
+        ? path.join(process.env.HOME ?? "", value.slice(2))
+        : value;
+    const candidate = path.resolve(expandedPath);
+    return existsSync(candidate) ? candidate : null;
+}
+function isLocalFileSource(sourceValue) {
+    const parsedUrl = parseUrl(sourceValue);
+    return !parsedUrl || parsedUrl.protocol === "file:";
+}
+function resolveLocalFileSourcePath(sourceValue) {
+    const parsedUrl = parseUrl(sourceValue);
+    return parsedUrl?.protocol === "file:"
+        ? fileURLToPath(parsedUrl)
+        : path.resolve(sourceValue);
+}
+async function fetchExternalImageBytes(sourceValue) {
+    const response = await fetch(sourceValue);
+    if (!response.ok) {
+        throw new Error(`Could not fetch slide source image: ${response.status} ${response.statusText}`);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+}
+async function detectImageContentType(bytes) {
+    try {
+        const metadata = await sharp(bytes).metadata();
+        if (metadata.format) {
+            return contentTypeForSharpFormat(metadata.format);
+        }
+    }
+    catch (error) {
+        throw new Error(`Slide source could not be decoded as an image: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return "image/png";
+}
+function contentTypeForSharpFormat(format) {
+    switch (format) {
+        case "jpeg":
+            return "image/jpeg";
+        case "png":
+            return "image/png";
+        case "webp":
+            return "image/webp";
+        case "gif":
+            return "image/gif";
+        case "avif":
+            return "image/avif";
+        case "tiff":
+            return "image/tiff";
+        case "svg":
+            return "image/svg+xml";
+        case "heif":
+            return "image/heif";
+        default:
+            return `image/${format}`;
+    }
+}
+async function generateMetaDetails(ctx, input) {
+    const prompt = buildMetaDetailsPrompt(input.slides, input.metaDetailsPrompt);
+    let lastError = null;
+    for (const provider of providerFailoverOrder(input.provider)) {
+        const textModel = resolveTextModelForAttempt(provider, input.configuredProvider, input.configuredTextModel);
+        try {
+            const response = await ctx.providers.generateText({
+                provider,
+                model: textModel,
+                prompt,
+                temperature: 0.7,
+            });
+            return parseMetaDetailsResponse(response.text, input.slides);
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            ctx.logger.warn("Metadata provider failed, trying next provider", {
+                provider,
+                model: textModel,
+                message: lastError.message,
+            });
+        }
+    }
+    throw lastError ?? new Error("No metadata provider succeeded.");
+}
+function buildMetaDetailsPrompt(slides, metaDetailsPrompt) {
+    return [
+        "You are writing TikTok post metadata for a vertical slideshow video.",
+        "Return only valid JSON with exactly these string keys: title, description, pinned_comment, location, song.",
+        "Do not include markdown fences or commentary.",
+        "Keep title under 90 characters.",
+        "Keep description under 300 characters.",
+        "Keep pinned_comment under 120 characters.",
+        "Keep location under 80 characters.",
+        "Keep song under 120 characters.",
+        "Write concise, high-performing, native-feeling TikTok social copy.",
+        "Use the slide captions and visual prompts to infer the post theme.",
+        metaDetailsPrompt
+            ? `Additional user guidance:\n${metaDetailsPrompt}`
+            : "No extra user guidance was supplied.",
+        "Slides:",
+        ...slides.map((slide) => [
+            `Slide ${slide.index + 1}:`,
+            `caption=${slide.overlayText}`,
+            `image_prompt=${slide.imagePrompt}`,
+            slide.imagePromptAttachments.length
+                ? `attachments=${slide.imagePromptAttachments.join(", ")}`
+                : "attachments=none",
+            `duration_ms=${slide.durationMs}`,
+        ].join("\n")),
+    ].join("\n\n");
+}
+function parseMetaDetailsResponse(raw, slides) {
+    const fallback = buildFallbackMetaDetails(slides);
+    const cleaned = raw
+        .trim()
+        .replace(/^```json\s*/i, "")
+        .replace(/^```\s*/i, "")
+        .replace(/\s*```$/i, "");
+    try {
+        const parsed = z
+            .object({
+            title: z.string().min(1),
+            description: z.string().min(1),
+            pinned_comment: z.string().min(1),
+            location: z.string().min(1),
+            song: z.string().min(1),
+        })
+            .parse(JSON.parse(cleaned));
+        return parsed;
+    }
+    catch {
+        return fallback;
+    }
+}
+function buildFallbackMetaDetails(slides) {
+    const leadCaption = slides[0]?.overlayText ?? "Watch this";
+    const supportingCaption = slides[1]?.overlayText ?? slides[0]?.imagePrompt ?? "See the full story";
+    return {
+        title: truncateText(leadCaption, 90),
+        description: truncateText(`${leadCaption}. ${supportingCaption}.`, 300),
+        pinned_comment: truncateText(`Which slide hit hardest: "${leadCaption}" or "${supportingCaption}"?`, 120),
+        location: "United States",
+        song: "Original Sound",
+    };
+}
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}
+async function renderFinishedSlide(imageBytes, overlayText, layout, textStyle) {
+    const layers = await buildTextLayers(overlayText, layout, textStyle);
+    return sharp(Buffer.from(imageBytes)).composite(layers).png().toBuffer();
+}
+async function buildTextLayers(overlayText, layout, textStyle) {
+    const safeWidth = FRAME.width - TIKTOK_SAFE_AREA.left - TIKTOK_SAFE_AREA.right;
+    const blockWidth = Math.round(safeWidth * clamp(layout.maxWidthPercent / 100, 0.4, 0.62));
+    const { fontSize, lines, lineHeight } = fitLinesToBlock(overlayText, blockWidth, textStyle.fontId);
+    const blockHeight = Math.round(lines.length * lineHeight + 10);
+    const { left: x, top: y } = resolveTextBlockRect(layout, blockWidth, blockHeight);
+    const textBlock = await renderMultilineTextBlock({
+        lines,
+        blockWidth,
+        blockHeight,
+        lineHeight,
+        fontSize,
+        fontFamily: textStyle.fontFamily,
+        fontWeight: textStyle.fontWeight,
+        fontPath: textStyle.fontPath,
+        color: textStyle.fill,
+        align: layout.align,
+    });
+    const rawLayers = [];
+    if (textStyle.backgroundColorHex) {
+        for (const metric of textBlock.lineMetrics) {
+            const chip = await buildTextChip({
+                width: Math.ceil(metric.width),
+                height: lineHeight,
+                fill: textStyle.backgroundColorHex,
+            });
+            rawLayers.push({
+                input: chip,
+                left: x + Math.round(metric.left) - TEXT_CHIP_PADDING_X,
+                top: y + metric.index * lineHeight - TEXT_CHIP_PADDING_Y,
+            });
+        }
+    }
+    const shadowLayers = await Promise.all(NATIVE_SHADOW_BLURS.map(async (blur) => ({
+        input: await renderShadowLayer({
+            textBuffer: textBlock.buffer,
+            width: blockWidth,
+            height: blockHeight,
+            shadowPadding: NATIVE_SHADOW_PADDING,
+            blur,
+        }),
+        left: x - NATIVE_SHADOW_PADDING,
+        top: y - NATIVE_SHADOW_PADDING,
+    })));
+    rawLayers.push(...shadowLayers, { input: textBlock.buffer, left: x, top: y });
+    const clippedLayers = await Promise.all(rawLayers.map((layer) => clipCompositeLayer(layer)));
+    return clippedLayers.filter((layer) => Boolean(layer));
+}
+function fitLinesToBlock(text, blockWidth, fontId) {
+    let fontSize = pickFontSize(text, fontId);
+    let lineHeight = pickLineHeight(fontSize, fontId);
+    let maxChars = approximateMaxChars(blockWidth, fontSize);
+    let lines = wrapText(text, maxChars);
+    while ((lines.length > 6 || longestLine(lines) > maxChars + 1) &&
+        fontSize > 34) {
+        fontSize -= 3;
+        lineHeight = pickLineHeight(fontSize, fontId);
+        maxChars = approximateMaxChars(blockWidth, fontSize);
+        lines = wrapText(text, maxChars);
+    }
+    return { fontSize, lines, lineHeight };
+}
+function pickFontSize(text, fontId) {
+    if (fontId === "yesteryear") {
+        if (text.length <= 22) {
+            return 74;
+        }
+        if (text.length <= 38) {
+            return 64;
+        }
+        return 54;
+    }
+    if (fontId === "georgia_bold") {
+        if (text.length <= 22) {
+            return 66;
+        }
+        if (text.length <= 38) {
+            return 58;
+        }
+        return 48;
+    }
+    if (text.length <= 22) {
+        return 58;
+    }
+    if (text.length <= 38) {
+        return 52;
+    }
+    if (text.length <= 62) {
+        return 46;
+    }
+    if (text.length <= 96) {
+        return 40;
+    }
+    return 36;
+}
+function pickLineHeight(fontSize, fontId) {
+    if (fontId === "yesteryear") {
+        return Math.round(fontSize * 1.04);
+    }
+    if (fontId === "georgia_bold") {
+        return Math.round(fontSize * 1.08);
+    }
+    return Math.round(fontSize * 1.12);
+}
+function approximateMaxChars(blockWidth, fontSize) {
+    return clamp(Math.floor(blockWidth / Math.max(20, fontSize * 0.42)), 12, 34);
+}
+async function renderMultilineTextBlock(input) {
+    if (input.fontPath) {
+        return renderMultilineTextPathBlock({
+            ...input,
+            fontPath: input.fontPath,
+        });
+    }
+    const markupSafe = input.lines.map((line) => escapePango(line)).join("\n");
+    const buffer = await sharp({
+        text: {
+            text: `<span foreground="${input.color}">${markupSafe}</span>`,
+            rgba: true,
+            width: input.blockWidth,
+            height: input.blockHeight,
+            align: input.align,
+            spacing: 0,
+            font: `${input.fontFamily} ${input.fontWeight} ${input.fontSize}`,
+        },
+    })
+        .png()
+        .toBuffer();
+    return {
+        buffer,
+        lineMetrics: estimateTextLineMetrics(input.lines, input.blockWidth, input.fontSize, input.align),
+    };
+}
+async function renderMultilineTextPathBlock(input) {
+    const font = loadOverlayFont(input.fontPath);
+    const canvasWidth = input.blockWidth;
+    const canvasHeight = input.blockHeight;
+    const baseline = Math.round(input.fontSize * 0.9);
+    const scale = input.fontSize / font.unitsPerEm;
+    const lineMetrics = [];
+    const pathData = input.lines
+        .map((line, lineIndex) => {
+        const run = font.layout(line);
+        const width = run.positions.reduce((sum, position) => sum + position.xAdvance * scale, 0);
+        const left = input.align === "center"
+            ? Math.max(0, (input.blockWidth - width) / 2)
+            : input.align === "right"
+                ? Math.max(0, input.blockWidth - width)
+                : 0;
+        lineMetrics.push({ index: lineIndex, left, width });
+        let penX = left;
+        const lineBaseline = baseline + lineIndex * input.lineHeight;
+        return run.glyphs
+            .map((glyph, glyphIndex) => {
+            const position = run.positions[glyphIndex];
+            const x = penX + position.xOffset * scale;
+            const y = lineBaseline - position.yOffset * scale;
+            penX += position.xAdvance * scale;
+            return `<path transform="translate(${roundSvgNumber(x)} ${roundSvgNumber(y)}) scale(${roundSvgNumber(scale)} ${roundSvgNumber(-scale)})" d="${glyph.path.toSVG()}"/>`;
+        })
+            .join("");
+    })
+        .join("");
+    const svg = `<svg width="${canvasWidth}" height="${canvasHeight}" viewBox="0 0 ${canvasWidth} ${canvasHeight}" xmlns="http://www.w3.org/2000/svg">
+    <g fill="${input.color}">${pathData}</g>
+  </svg>`;
+    return {
+        buffer: await sharp(Buffer.from(svg)).png().toBuffer(),
+        lineMetrics,
+    };
+}
+function estimateTextLineMetrics(lines, blockWidth, fontSize, align) {
+    return lines.map((line, index) => {
+        const width = Math.min(blockWidth, Math.max(fontSize, line.length * fontSize * 0.48));
+        const left = align === "center"
+            ? Math.max(0, (blockWidth - width) / 2)
+            : align === "right"
+                ? Math.max(0, blockWidth - width)
+                : 0;
+        return { index, left, width };
+    });
+}
+function loadOverlayFont(fontPath) {
+    const cached = parsedFontCache.get(fontPath);
+    if (cached) {
+        return cached;
+    }
+    const loaded = fontkit.openSync(fontPath);
+    const font = loaded.type === "TTC" || loaded.type === "DFont"
+        ? loaded.fonts[0]
+        : loaded;
+    if (!font) {
+        throw new Error(`Could not load overlay font from ${fontPath}.`);
+    }
+    parsedFontCache.set(fontPath, font);
+    return font;
+}
+function roundSvgNumber(value) {
+    return Number(value.toFixed(4));
+}
+async function renderShadowLayer(input) {
+    return sharp({
+        create: {
+            width: input.width + input.shadowPadding * 2,
+            height: input.height + input.shadowPadding * 2,
+            channels: 4,
+            background: { r: 0, g: 0, b: 0, alpha: 0 },
+        },
+    })
+        .composite([
+        {
+            input: input.textBuffer,
+            left: input.shadowPadding,
+            top: input.shadowPadding,
+        },
+    ])
+        .modulate({ brightness: 0 })
+        .linear(0, 0)
+        .blur(input.blur)
+        .png()
+        .toBuffer();
+}
+async function buildTextChip(input) {
+    const chipWidth = input.width + TEXT_CHIP_PADDING_X * 2;
+    const chipHeight = input.height + TEXT_CHIP_PADDING_Y * 2;
+    return sharp(Buffer.from(`<svg width="${chipWidth}" height="${chipHeight}" xmlns="http://www.w3.org/2000/svg">
+      <rect x="0" y="0" width="${chipWidth}" height="${chipHeight}" rx="${TEXT_CHIP_RADIUS}" ry="${TEXT_CHIP_RADIUS}" fill="${input.fill}" fill-opacity="${TEXT_CHIP_OPACITY}"/>
+    </svg>`))
+        .png()
+        .toBuffer();
+}
+function wrapText(text, maxChars) {
+    const words = text.trim().split(/\s+/).filter(Boolean);
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        const candidate = current ? `${current} ${word}` : word;
+        if (candidate.length <= maxChars || !current) {
+            current = candidate;
+            continue;
+        }
+        lines.push(current);
+        current = word;
+    }
+    if (current) {
+        lines.push(current);
+    }
+    return lines.length ? lines : [text];
+}
+function longestLine(lines) {
+    return lines.reduce((longest, line) => Math.max(longest, line.length), 0);
+}
+async function portraitScore(input) {
+    const metadata = await sharp(Buffer.from(input)).rotate().metadata();
+    const width = metadata.width ?? FRAME.width;
+    const height = metadata.height ?? FRAME.height;
+    const aspect = width / height;
+    const thumbnailWidth = 96;
+    const thumbnailHeight = 170;
+    const sample = await sharp(Buffer.from(input))
+        .rotate()
+        .resize(thumbnailWidth, thumbnailHeight, { fit: "fill" })
+        .grayscale()
+        .raw()
+        .toBuffer();
+    const edgeContrast = edgeBandContrast(sample, thumbnailWidth, thumbnailHeight);
+    const edgeFlatnessPenalty = edgeBandFlatnessPenalty(sample, thumbnailWidth, thumbnailHeight);
+    return Math.abs(aspect - 9 / 16) + edgeContrast + edgeFlatnessPenalty;
+}
+async function chooseLayoutFromImage(imageBytes, overlayText) {
+    const thumbnailWidth = 108;
+    const thumbnailHeight = 192;
+    const sample = await sharp(Buffer.from(imageBytes))
+        .resize(thumbnailWidth, thumbnailHeight, { fit: "fill" })
+        .grayscale()
+        .raw()
+        .toBuffer();
+    const candidates = buildLayoutCandidates(overlayText);
+    let best = defaultLayout();
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        const estimate = estimateTextBlock(overlayText, candidate);
+        const region = regionForLayout(candidate, estimate.blockWidth, estimate.blockHeight);
+        const score = scoreLayoutRegion(sample, thumbnailWidth, thumbnailHeight, region) +
+            candidate.stylePenalty;
+        if (score < bestScore) {
+            best = candidate;
+            bestScore = score;
+        }
+    }
+    return {
+        zone: best.zone,
+        align: best.align,
+        maxWidthPercent: best.maxWidthPercent,
+        anchorXPercent: best.anchorXPercent,
+        anchorYPercent: best.anchorYPercent,
+        justification: `${best.justification} Selected by local safe-zone scoring to minimize busy backgrounds and avoid TikTok UI chrome.`,
+    };
+}
+async function chooseSlideLayout(ctx, input) {
+    if (input.imageUrl) {
+        try {
+            const analysis = await ctx.providers.analyzeImageLayout({
+                provider: input.provider,
+                model: input.model,
+                imageUrl: input.imageUrl,
+                overlayText: input.overlayText,
+            });
+            return normalizeAiLayout(analysis);
+        }
+        catch (error) {
+            ctx.logger.warn("AI layout analysis failed, falling back to local scorer", {
+                provider: input.provider,
+                model: input.model,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return chooseLayoutFromImage(input.imageBytes, input.overlayText);
+}
+function normalizeAiLayout(input) {
+    const normalizedAlign = input.align === "right" ? "center" : input.align;
+    const anchorXPercent = normalizedAlign === "center"
+        ? 0.5
+        : normalizedAlign === "left"
+            ? 0.38
+            : 0.62;
+    const anchorYPercent = input.zone === "top" ? 0.18 : input.zone === "bottom" ? 0.38 : 0.28;
+    return {
+        zone: input.zone === "bottom" ? "center" : input.zone,
+        align: normalizedAlign,
+        maxWidthPercent: clamp(input.maxWidthPercent, 46, 62),
+        anchorXPercent,
+        anchorYPercent,
+        justification: `${input.justification} Normalized toward centered TikTok-native caption placement.`,
+    };
+}
+function estimateTextBlock(text, layout) {
+    const safeWidth = FRAME.width - TIKTOK_SAFE_AREA.left - TIKTOK_SAFE_AREA.right;
+    const centeredBounds = resolveNativeUiTextPaddingBounds();
+    const availableWidth = layout.align === "center"
+        ? FRAME.width - centeredBounds.minLeft * 2
+        : safeWidth;
+    const blockWidth = Math.round(availableWidth * clamp(layout.maxWidthPercent / 100, 0.4, 0.62));
+    const { fontSize, lines, lineHeight } = fitLinesToBlock(text, blockWidth, "montserrat");
+    return {
+        blockWidth,
+        blockHeight: Math.round(lines.length * lineHeight + 10),
+        fontSize,
+    };
+}
+function regionForLayout(layout, blockWidth, blockHeight) {
+    return resolveTextBlockRect(layout, blockWidth, blockHeight);
+}
+function resolveTextBlockRect(layout, blockWidth, blockHeight) {
+    const safeWidth = FRAME.width - TIKTOK_SAFE_AREA.left - TIKTOK_SAFE_AREA.right;
+    const safeHeight = FRAME.height - TIKTOK_SAFE_AREA.top - TIKTOK_SAFE_AREA.bottom;
+    const centeredBounds = resolveNativeUiTextPaddingBounds(blockWidth);
+    if (layout.anchorXPercent !== undefined &&
+        layout.anchorYPercent !== undefined) {
+        const centeredX = clamp(Math.round((FRAME.width - blockWidth) / 2), centeredBounds.minLeft, centeredBounds.maxLeft);
+        return {
+            left: layout.align === "center"
+                ? centeredX
+                : TIKTOK_SAFE_AREA.left +
+                    Math.round((safeWidth - blockWidth) * clamp(layout.anchorXPercent, 0, 1)),
+            top: TIKTOK_SAFE_AREA.top +
+                Math.round((safeHeight - blockHeight) * clamp(layout.anchorYPercent, 0, 1)),
+            width: blockWidth,
+            height: blockHeight,
+        };
+    }
+    const x = layout.align === "left"
+        ? TIKTOK_SAFE_AREA.left
+        : layout.align === "center"
+            ? clamp(Math.round((FRAME.width - blockWidth) / 2), centeredBounds.minLeft, centeredBounds.maxLeft)
+            : FRAME.width - TIKTOK_SAFE_AREA.right - blockWidth;
+    const y = layout.zone === "top"
+        ? TIKTOK_SAFE_AREA.top + 72
+        : layout.zone === "center"
+            ? TIKTOK_SAFE_AREA.top + Math.round(safeHeight * 0.2)
+            : FRAME.height - TIKTOK_SAFE_AREA.bottom - blockHeight - 120;
+    return {
+        left: x,
+        top: y,
+        width: blockWidth,
+        height: blockHeight,
+    };
+}
+function resolveNativeUiTextPaddingBounds(blockWidth = 0) {
+    const horizontalPadding = Math.round(FRAME.width *
+        ((NATIVE_UI_TEXT_ZONE.maxCenterXPercent -
+            NATIVE_UI_TEXT_ZONE.minCenterXPercent) /
+            2));
+    return {
+        minLeft: horizontalPadding,
+        maxLeft: Math.max(horizontalPadding, FRAME.width - horizontalPadding - blockWidth),
+    };
+}
+function scoreLayoutRegion(sample, width, height, region) {
+    const inner = sampleStats(sample, width, height, region, 0);
+    const outer = sampleStats(sample, width, height, region, 44);
+    const halo = sampleStats(sample, width, height, region, 110);
+    const edgePenalty = (region.left < 112 ? 6 : 0) +
+        (region.top < 340 ? 18 : 0) +
+        (region.top + region.height > FRAME.height - 560 ? 18 : 0);
+    const readabilityPenalty = Math.max(0, inner.mean - 205) * 0.24;
+    const lowContrastPenalty = Math.abs(inner.mean - outer.mean) < 10 ? 6 : 0;
+    const haloPenalty = halo.detail * 0.35 + halo.variance * 0.01;
+    return (inner.detail * 1.35 +
+        inner.variance * 0.022 +
+        outer.detail * 0.45 +
+        readabilityPenalty +
+        lowContrastPenalty +
+        haloPenalty +
+        edgePenalty);
+}
+function sampleStats(sample, width, height, region, padding) {
+    const left = clamp(Math.floor((region.left / FRAME.width) * width), 0, width - 1);
+    const top = clamp(Math.floor((region.top / FRAME.height) * height), 0, height - 1);
+    const right = clamp(Math.ceil(((region.left + region.width) / FRAME.width) * width), left + 1, width);
+    const bottom = clamp(Math.ceil(((region.top + region.height) / FRAME.height) * height), top + 1, height);
+    const padX = Math.round((padding / FRAME.width) * width);
+    const padY = Math.round((padding / FRAME.height) * height);
+    const paddedLeft = clamp(left - padX, 0, width - 1);
+    const paddedTop = clamp(top - padY, 0, height - 1);
+    const paddedRight = clamp(right + padX, paddedLeft + 1, width);
+    const paddedBottom = clamp(bottom + padY, paddedTop + 1, height);
+    let total = 0;
+    let totalSq = 0;
+    let detail = 0;
+    let count = 0;
+    for (let y = paddedTop; y < paddedBottom; y += 1) {
+        for (let x = paddedLeft; x < paddedRight; x += 1) {
+            if (padding > 0 && x >= left && x < right && y >= top && y < bottom) {
+                continue;
+            }
+            const index = y * width + x;
+            const current = sample[index] ?? 0;
+            const leftPixel = x > 0 ? (sample[index - 1] ?? current) : current;
+            const upPixel = y > 0 ? (sample[index - width] ?? current) : current;
+            total += current;
+            totalSq += current * current;
+            detail += Math.abs(current - leftPixel) + Math.abs(current - upPixel);
+            count += 1;
+        }
+    }
+    const mean = total / Math.max(count, 1);
+    const variance = Math.max(0, totalSq / Math.max(count, 1) - mean * mean);
+    return {
+        mean,
+        variance,
+        detail: detail / Math.max(count, 1),
+    };
+}
+function edgeBandContrast(sample, width, height) {
+    const bandHeight = Math.max(8, Math.floor(height * 0.16));
+    const top = bandActivity(sample, width, height, 0, bandHeight);
+    const bottom = bandActivity(sample, width, height, height - bandHeight, height);
+    return (top + bottom) / 220;
+}
+function edgeBandFlatnessPenalty(sample, width, height) {
+    const bandHeight = Math.max(8, Math.floor(height * 0.16));
+    const centerStart = Math.max(0, Math.floor(height * 0.34));
+    const centerEnd = Math.min(height, Math.ceil(height * 0.66));
+    const top = bandActivity(sample, width, height, 0, bandHeight);
+    const bottom = bandActivity(sample, width, height, height - bandHeight, height);
+    const center = bandActivity(sample, width, height, centerStart, centerEnd);
+    const edgeAverage = (top + bottom) / 2;
+    if (center <= 0) {
+        return 0;
+    }
+    const ratio = edgeAverage / center;
+    if (ratio >= 0.72) {
+        return 0;
+    }
+    return (0.72 - ratio) * 3.4;
+}
+function bandActivity(sample, width, height, startY, endY) {
+    let detail = 0;
+    let count = 0;
+    for (let y = startY; y < endY; y += 1) {
+        for (let x = 1; x < width; x += 1) {
+            const index = y * width + x;
+            const current = sample[index] ?? 0;
+            const prev = sample[index - 1] ?? current;
+            detail += Math.abs(current - prev);
+            count += 1;
+        }
+    }
+    return detail / Math.max(count, 1);
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function escapePango(text) {
+    return text
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+async function clipCompositeLayer(layer) {
+    const metadata = await sharp(layer.input).metadata();
+    const width = metadata.width ?? 0;
+    const height = metadata.height ?? 0;
+    if (!width || !height) {
+        return null;
+    }
+    const left = Math.max(0, layer.left);
+    const top = Math.max(0, layer.top);
+    const cropLeft = Math.max(0, -layer.left);
+    const cropTop = Math.max(0, -layer.top);
+    const availableWidth = FRAME.width - left;
+    const availableHeight = FRAME.height - top;
+    const cropWidth = Math.min(width - cropLeft, availableWidth);
+    const cropHeight = Math.min(height - cropTop, availableHeight);
+    if (cropWidth <= 0 || cropHeight <= 0) {
+        return null;
+    }
+    if (cropLeft === 0 &&
+        cropTop === 0 &&
+        cropWidth === width &&
+        cropHeight === height) {
+        return {
+            input: layer.input,
+            left,
+            top,
+        };
+    }
+    const input = await sharp(layer.input)
+        .extract({
+        left: cropLeft,
+        top: cropTop,
+        width: cropWidth,
+        height: cropHeight,
+    })
+        .png()
+        .toBuffer();
+    return {
+        input,
+        left,
+        top,
+    };
+}
+function buildLayoutCandidates(overlayText) {
+    const prefersCenteredText = overlayText.trim().length <= 42;
+    const widthPercents = prefersCenteredText ? [48, 52, 56] : [50, 54, 58];
+    const centerAnchors = prefersCenteredText
+        ? [0.44, 0.5, 0.56]
+        : [0.42, 0.5, 0.58];
+    const yAnchors = [0.16, 0.22, 0.28, 0.34, 0.4];
+    const candidates = [];
+    for (const maxWidthPercent of widthPercents) {
+        for (const anchorYPercent of yAnchors) {
+            for (const anchorXPercent of centerAnchors) {
+                candidates.push({
+                    zone: anchorYPercent < 0.22 ? "top" : "center",
+                    align: "center",
+                    maxWidthPercent,
+                    anchorXPercent,
+                    anchorYPercent,
+                    justification: "Image-aware centered native TikTok caption zone.",
+                    stylePenalty: scoreNativeUiAnchor(anchorXPercent, anchorYPercent) +
+                        (prefersCenteredText ? 0 : 4),
+                });
+            }
+        }
+    }
+    return candidates;
+}
+function scoreNativeUiAnchor(anchorXPercent, anchorYPercent) {
+    let penalty = 0;
+    if (anchorXPercent < NATIVE_UI_TEXT_ZONE.minCenterXPercent ||
+        anchorXPercent > NATIVE_UI_TEXT_ZONE.maxCenterXPercent) {
+        penalty += 10;
+    }
+    if (anchorYPercent < NATIVE_UI_TEXT_ZONE.minCenterYPercent ||
+        anchorYPercent > NATIVE_UI_TEXT_ZONE.maxCenterYPercent) {
+        penalty += 10;
+    }
+    penalty += Math.abs(anchorXPercent - 0.5) * 24;
+    penalty += Math.abs(anchorYPercent - 0.28) * 18;
+    return penalty;
+}
+function resolveRemotionEntryPoint() {
+    const builtPath = fileURLToPath(new URL("./remotion/index.js", import.meta.url));
+    if (existsSync(builtPath)) {
+        return builtPath;
+    }
+    return fileURLToPath(new URL("./remotion/index.tsx", import.meta.url));
+}
+function resolveTemplateRuntimeConfig() {
+    const candidates = [
+        fileURLToPath(new URL("../template.config.json", import.meta.url)),
+        path.resolve(process.cwd(), "templates/vidfarm_template_0000/template.config.json"),
+    ];
+    for (const candidate of candidates) {
+        if (!existsSync(candidate)) {
+            continue;
+        }
+        return JSON.parse(readFileSync(candidate, "utf8"));
+    }
+    return {};
+}
+function resolveSkillPath() {
+    const builtPath = fileURLToPath(new URL("../SKILL.md", import.meta.url));
+    if (existsSync(builtPath)) {
+        return builtPath;
+    }
+    return path.resolve(process.cwd(), "templates/vidfarm_template_0000/SKILL.md");
+}
+function resolveOverlayFonts() {
+    const resolved = Object.fromEntries(TEMPLATE_FONT_OPTIONS.map((option) => {
+        const assetFile = "assetFile" in option ? option.assetFile : undefined;
+        const fontsourceFile = "fontsourceFile" in option ? option.fontsourceFile : undefined;
+        const candidates = [
+            ...(fontsourceFile
+                ? [
+                    path.resolve(process.cwd(), "node_modules", fontsourceFile),
+                    path.resolve(process.cwd(), "templates/vidfarm_template_0000/node_modules", fontsourceFile),
+                ]
+                : []),
+            ...(assetFile
+                ? [
+                    fileURLToPath(new URL(`../assets/${assetFile}`, import.meta.url)),
+                    path.resolve(process.cwd(), `templates/vidfarm_template_0000/assets/${assetFile}`),
+                ]
+                : []),
+        ];
+        for (const candidate of candidates) {
+            if (existsSync(candidate)) {
+                return [option.id, { path: candidate }];
+            }
+        }
+        throw new Error(`Could not resolve local overlay font asset for ${option.label}.`);
+    }));
+    return resolved;
+}
+function resolveCustomCaptionFontPath(customPath) {
+    const normalizedPath = customPath.replace(/^\.?\//, "");
+    const candidates = [
+        path.isAbsolute(customPath) ? customPath : null,
+        fileURLToPath(new URL(`../${normalizedPath}`, import.meta.url)),
+        path.resolve(process.cwd(), customPath),
+        path.resolve(process.cwd(), "templates/vidfarm_template_0000", customPath),
+    ].filter((candidate) => Boolean(candidate));
+    return candidates.find(existsSync) ?? null;
+}