@mevdragon/vidfarm-devcli 0.2.1 → 0.2.3

package/templates/template_0000/src/template.js

@@ -4,63 +4,113 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 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";
-const TEMPLATE_ID = "template-0000";
+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
+    bottom: 408,
 };
 const NATIVE_UI_TEXT_ZONE = {
     minCenterXPercent: 0.38,
     maxCenterXPercent: 0.62,
     minCenterYPercent: 0.2,
-    maxCenterYPercent: 0.58
+    maxCenterYPercent: 0.58,
 };
 const TEXT_BACKGROUND_NONE = "none";
+// 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)])
+    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)
+    duration_ms: z.number().int().min(500).max(30000).default(4000),
 });
-const slideInputSchema = z.union([legacySlideInputSchema, structuredSlideInputSchema]);
+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()
+    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)
+    durationMs: z.number().int().min(500).max(30000),
 });
 const renderVideoInputSchema = z.object({
-    slides: z.array(renderSlideSchema).min(1).max(20)
+    slides: z.array(renderSlideSchema).min(1).max(20),
 });
 const supportedImageProviders = ["openai", "gemini", "openrouter"];
 const remotionEntryPoint = resolveRemotionEntryPoint();
-const remotionRuntimeConfig = resolveTemplateRemotionRuntimeConfig();
+const templateRuntimeConfig = resolveTemplateRuntimeConfig();
+const remotionRuntimeConfig = {
+    serveUrl: templateRuntimeConfig.remotion?.serve_url ?? undefined,
+};
 const skillPath = resolveSkillPath();
 const overlayFonts = resolveOverlayFonts();
 export const template0000Definition = defineTemplate({
     id: TEMPLATE_ID,
+    slugId: TEMPLATE_SLUG_ID,
     version: "1.0.0",
-    description: "Starter TikTok-safe slideshow template with staged image generation, text compositing, and optional Remotion video rendering.",
+    about: {
+        title: "Template 0000",
+        description: "Starter TikTok-safe slideshow template with staged image generation, text compositing, and optional Remotion video rendering.",
+        viral_dna: templateViralDna,
+        visual_dna: templateVisualDna,
+        preview_media: [...TEMPLATE_PREVIEW_MEDIA],
+        link_to_original: templateLinkToOriginal,
+    },
     skillPath,
     configSchema: z.object({
         defaultProvider: z.enum(supportedImageProviders).default("gemini"),
         textModel: z.string().optional(),
         imageModel: z.string().optional(),
         captionFont: z.enum(TEMPLATE_FONT_IDS).default("montserrat"),
-        captionBackgroundColor: z.enum([TEXT_BACKGROUND_NONE, ...TEMPLATE_TEXT_BACKGROUND_COLOR_IDS]).default(TEXT_BACKGROUND_NONE),
-        renderCompositionId: z.string().default(COMPOSITION_ID)
+        captionBackgroundColor: z
+            .enum([TEXT_BACKGROUND_NONE, ...TEMPLATE_TEXT_BACKGROUND_COLOR_IDS])
+            .default(TEXT_BACKGROUND_NONE),
+        renderCompositionId: z.string().default(COMPOSITION_ID),
     }),
     operations: {
         create_slideshow: {
@@ -73,13 +123,15 @@ export const template0000Definition = defineTemplate({
                     ["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"],
+                        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
-                    }
+                        duration_ms: 3200,
+                    },
                 ],
-                meta_details_prompt: "Target US TikTok skincare and startup audiences. Make the hook curiosity-driven, natural, and UGC-native."
-            }
+                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.",
@@ -88,36 +140,60 @@ export const template0000Definition = defineTemplate({
             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 }
-                ]
-            }
-        }
+                    {
+                        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 textModel = String(ctx.templateConfig.textModel ?? defaultTextModelForProvider(provider));
-            const imageModel = String(ctx.templateConfig.imageModel ?? defaultImageModelForProvider(provider));
+            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 { imagePrompt, imagePromptAttachments, overlayText, durationMs } = normalizeSlideInput(rawSlide);
-                ctx.logger.progress(0.08 + (index / payload.slides.length) * 0.42, `Generating slide ${index + 1} image`);
-                const image = await generatePortraitCandidateImage(ctx, {
-                    provider,
-                    imageModel,
-                    imagePrompt,
-                    imagePromptAttachments,
-                    overlayText
-                });
-                await ctx.billing.record({
-                    type: "ai_generation",
-                    costUsd: 0.04,
-                    metadata: { stage: "image_generation", slideIndex: index, model: imageModel }
-                });
+                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, {
@@ -129,8 +205,8 @@ export const template0000Definition = defineTemplate({
                         revisedPrompt: image.revisedPrompt,
                         width: normalizedImage.width,
                         height: normalizedImage.height,
-                        aspectRatio: "9:16"
-                    }
+                        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, {
@@ -138,7 +214,7 @@ export const template0000Definition = defineTemplate({
                     model: textModel,
                     imageBytes: normalizedImage.bytes,
                     imageUrl: backgroundArtifact.url,
-                    overlayText
+                    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);
@@ -150,11 +226,13 @@ export const template0000Definition = defineTemplate({
                         overlayText,
                         layout,
                         aspectRatio: "9:16",
-                        kind: "finished_slide_frame"
-                    }
+                        kind: "finished_slide_frame",
+                    },
                 });
                 slides.push({
                     index,
+                    sourceType,
+                    sourceValue,
                     imagePrompt,
                     imagePromptAttachments,
                     overlayText,
@@ -163,20 +241,22 @@ export const template0000Definition = defineTemplate({
                     frameImageUrl: frameArtifact.url,
                     prompt: image.prompt,
                     revisedPrompt: image.revisedPrompt,
-                    layout
+                    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
+                metaDetailsPrompt: payload.meta_details_prompt,
             });
             await ctx.billing.record({
                 type: "ai_generation",
                 costUsd: 0.01,
-                metadata: { stage: "meta_details_generation", model: textModel }
+                metadata: { stage: "meta_details_generation", model: textModel },
             });
             ctx.logger.progress(0.78, "Saving slideshow manifest");
             const manifest = {
@@ -190,19 +270,21 @@ export const template0000Definition = defineTemplate({
                     backgroundColorHex: textStyle.backgroundColorHex,
                     shadow: "soft native TikTok-style black drop shadow",
                     availableFonts: TEMPLATE_FONT_OPTIONS,
-                    availableBackgroundColors: TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS
+                    availableBackgroundColors: TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS,
                 },
                 safeArea: TIKTOK_SAFE_AREA,
                 metaDetails,
-                slides
+                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));
+            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
+                fileCount: files.length,
             });
             return {
                 progress: 1,
@@ -215,19 +297,26 @@ export const template0000Definition = defineTemplate({
                         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
-                        }))
+                            durationMs: slide.durationMs,
+                        })),
                     },
                     renderVideoInput: {
                         slides: slides
-                            .map((slide) => slide.frameImageUrl ? { imageUrl: slide.frameImageUrl, durationMs: slide.durationMs } : null)
-                            .filter((slide) => Boolean(slide))
+                            .map((slide) => slide.frameImageUrl
+                            ? {
+                                imageUrl: slide.frameImageUrl,
+                                durationMs: slide.durationMs,
+                            }
+                            : null)
+                            .filter((slide) => Boolean(slide)),
                     },
-                    slides
-                }
+                    slides,
+                },
             };
         },
         async renderVideoWorkflow(ctx, input) {
@@ -243,13 +332,13 @@ export const template0000Definition = defineTemplate({
                 outputKey: "renders/final.mp4",
                 inputProps: {
                     slides,
-                    fps: 30
-                }
+                    fps: 30,
+                },
             });
             await ctx.billing.record({
                 type: "render",
                 costUsd: 0.35,
-                metadata: render.metadata
+                metadata: render.metadata,
             });
             const files = slides.map((slide) => slide.imageUrl);
             if (render.outputUrl) {
@@ -257,18 +346,18 @@ export const template0000Definition = defineTemplate({
             }
             ctx.logger.progress(1, "Slideshow video complete", {
                 fileCount: files.length,
-                renderId: render.renderId
+                renderId: render.renderId,
             });
             return {
                 progress: 1,
                 output: {
                     files,
                     render,
-                    slides
-                }
+                    slides,
+                },
             };
-        }
-    }
+        },
+    },
 });
 const IMAGE_PROMPT_SYSTEM_WRAPPER = [
     "Create an exact 9:16 portrait slideshow image for a TikTok-style vertical video.",
@@ -287,18 +376,20 @@ const IMAGE_PROMPT_SYSTEM_WRAPPER = [
     "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.",
-    "Use cinematic lighting, crisp detail, and framing that already fits an exact 9:16 portrait frame.",
-    "Avoid giant blank ceiling, wall, floor, or sky bands that make the frame feel padded or zoomed out."
+    "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.`]
+            ? [
+                `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.`
+        `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) {
@@ -310,44 +401,61 @@ async function generatePortraitCandidateImage(ctx, input) {
             "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."
+            "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."
+            "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")
+            "Crop decisively and favor a native social-video camera distance.",
+        ].join("\n"),
     ];
     let best = null;
-    for (const prompt of attempts) {
-        const image = await ctx.providers.generateImage({
-            provider: input.provider,
-            model: input.imageModel,
-            prompt,
-            promptAttachments: input.imagePromptAttachments,
-            size: sourceImageSizeForProvider(input.provider),
-            aspectRatio: "9:16",
-            imageSize: sourceImageOutputSizeForProvider(input.provider, input.imageModel)
-        });
-        const score = await portraitScore(image.bytes);
-        if (!best || score < best.score) {
-            best = { ...image, prompt, score };
+    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;
+            }
         }
-        if (score <= 0.16) {
-            break;
+        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 new Error("No image candidate was generated.");
+        throw lastError ?? new Error("No image candidate was generated.");
     }
     return best;
 }
@@ -358,7 +466,7 @@ function defaultLayout() {
         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."
+        justification: "Default placement uses a centered TikTok-native text zone in the middle third of the safe frame.",
     };
 }
 function parseImageProvider(value) {
@@ -368,11 +476,12 @@ function parseImageProvider(value) {
     return "gemini";
 }
 function isImageProvider(value) {
-    return typeof value === "string" && supportedImageProviders.includes(value);
+    return (typeof value === "string" &&
+        supportedImageProviders.includes(value));
 }
 function sourceImageSizeForProvider(provider) {
     if (provider === "openai") {
-        return "1024x1792";
+        return "1024x1536";
     }
     return "1080x1920";
 }
@@ -383,7 +492,7 @@ function defaultImageModelForProvider(provider) {
     if (provider === "openrouter") {
         return "bytedance-seed/seedream-4.5";
     }
-    return "gemini-3.1-flash-image-preview";
+    return "gemini-2.5-flash-image";
 }
 function defaultTextModelForProvider(provider) {
     if (provider === "openai") {
@@ -401,32 +510,56 @@ function sourceImageOutputSizeForProvider(provider, model) {
     if (provider !== "gemini") {
         return undefined;
     }
-    if (model === "gemini-3.1-flash-image-preview" || model === "gemini-3-pro-image-preview") {
+    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 = isTemplateFontId(config.captionFont) ? config.captionFont : "montserrat";
-    const backgroundColorId = config.captionBackgroundColor === TEXT_BACKGROUND_NONE || isTemplateBackgroundColorId(config.captionBackgroundColor)
+    const fontId = isTemplateFontId(config.captionFont)
+        ? config.captionFont
+        : "montserrat";
+    const backgroundColorId = config.captionBackgroundColor === TEXT_BACKGROUND_NONE ||
+        isTemplateBackgroundColorId(config.captionBackgroundColor)
         ? config.captionBackgroundColor
         : TEXT_BACKGROUND_NONE;
-    const fontOption = TEMPLATE_FONT_OPTIONS.find((option) => option.id === fontId) ?? TEMPLATE_FONT_OPTIONS[1];
+    const fontOption = TEMPLATE_FONT_OPTIONS.find((option) => option.id === fontId) ??
+        TEMPLATE_FONT_OPTIONS[1];
     const backgroundOption = backgroundColorId && backgroundColorId !== TEXT_BACKGROUND_NONE
-        ? TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS.find((option) => option.id === backgroundColorId) ?? null
+        ? (TEMPLATE_TEXT_BACKGROUND_COLOR_OPTIONS.find((option) => option.id === backgroundColorId) ?? null)
         : null;
     return {
         fontId,
         fontFamily: fontOption.family,
         backgroundColorId: backgroundColorId ?? TEXT_BACKGROUND_NONE,
-        backgroundColorHex: backgroundOption?.hex ?? null
+        backgroundColorHex: backgroundOption?.hex ?? null,
     };
 }
 function isTemplateFontId(value) {
-    return typeof value === "string" && TEMPLATE_FONT_IDS.includes(value);
+    return (typeof value === "string" &&
+        TEMPLATE_FONT_IDS.includes(value));
 }
 function isTemplateBackgroundColorId(value) {
-    return typeof value === "string" && TEMPLATE_TEXT_BACKGROUND_COLOR_IDS.includes(value);
+    return (typeof value === "string" &&
+        TEMPLATE_TEXT_BACKGROUND_COLOR_IDS.includes(value));
 }
 function pad2(value) {
     return String(value).padStart(2, "0");
@@ -439,42 +572,47 @@ const slideshowManifestSchema = z.object({
     size: z.object({
         width: z.number(),
         height: z.number(),
-        aspectRatio: z.literal("9:16")
+        aspectRatio: z.literal("9:16"),
     }),
     textStyle: z.object({
         fontId: z.enum(TEMPLATE_FONT_IDS),
         fontFamily: z.string(),
         fill: z.string(),
-        backgroundColorId: z.enum([TEXT_BACKGROUND_NONE, ...TEMPLATE_TEXT_BACKGROUND_COLOR_IDS]),
+        backgroundColorId: z.enum([
+            TEXT_BACKGROUND_NONE,
+            ...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(),
-            assetFile: z.string()
+            assetFile: z.string(),
         })),
         availableBackgroundColors: z.array(z.object({
             id: z.enum(TEMPLATE_TEXT_BACKGROUND_COLOR_IDS),
             label: z.string(),
-            hex: z.string()
-        }))
+            hex: z.string(),
+        })),
     }),
     safeArea: z.object({
         left: z.number(),
         right: z.number(),
         top: z.number(),
-        bottom: z.number()
+        bottom: z.number(),
     }),
     metaDetails: z.object({
         title: z.string(),
         description: z.string(),
         pinned_comment: z.string(),
         location: z.string(),
-        song: 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(),
@@ -489,35 +627,160 @@ const slideshowManifestSchema = z.object({
             maxWidthPercent: z.number(),
             anchorXPercent: z.number().optional(),
             anchorYPercent: z.number().optional(),
-            justification: z.string()
-        })
-    }))
+            justification: z.string(),
+        }),
+    })),
 });
 function normalizeSlideInput(input) {
     if (Array.isArray(input)) {
-        return {
-            imagePrompt: input[0],
+        return normalizeSlideFields({
+            primarySource: input[0],
             imagePromptAttachments: [],
             overlayText: input[1],
-            durationMs: input[2] ?? 4000
-        };
+            durationMs: input[2] ?? 4000,
+        });
     }
-    return {
-        imagePrompt: input.image_prompt,
+    return normalizeSlideFields({
+        primarySource: input.image_prompt,
         imagePromptAttachments: input.image_prompt_attachments,
         overlayText: input.caption,
-        durationMs: input.duration_ms
+        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);
-    const response = await ctx.providers.generateText({
-        provider: input.provider,
-        model: input.textModel,
-        prompt,
-        temperature: 0.7
-    });
-    return parseMetaDetailsResponse(response.text, input.slides);
+    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 [
@@ -531,28 +794,38 @@ function buildMetaDetailsPrompt(slides, metaDetailsPrompt) {
         "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.",
+        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"))
+            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, "");
+    const cleaned = raw
+        .trim()
+        .replace(/^```json\s*/i, "")
+        .replace(/^```\s*/i, "")
+        .replace(/\s*```$/i, "");
     try {
-        const parsed = z.object({
+        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));
+            song: z.string().min(1),
+        })
+            .parse(JSON.parse(cleaned));
         return parsed;
     }
     catch {
@@ -567,7 +840,7 @@ function buildFallbackMetaDetails(slides) {
         description: truncateText(`${leadCaption}. ${supportingCaption}.`, 300),
         pinned_comment: truncateText(`Which slide hit hardest: "${leadCaption}" or "${supportingCaption}"?`, 120),
         location: "United States",
-        song: "Original Sound"
+        song: "Original Sound",
     };
 }
 function truncateText(value, maxLength) {
@@ -578,10 +851,7 @@ function truncateText(value, maxLength) {
 }
 async function renderFinishedSlide(imageBytes, overlayText, layout, textStyle) {
     const layers = await buildTextLayers(overlayText, layout, textStyle);
-    return sharp(Buffer.from(imageBytes))
-        .composite(layers)
-        .png()
-        .toBuffer();
+    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;
@@ -598,7 +868,7 @@ async function buildTextLayers(overlayText, layout, textStyle) {
         blockX: x,
         blockY: y,
         layout,
-        textStyle
+        textStyle,
     })))).flat();
     const clippedLayers = await Promise.all(rawLayers.map((layer) => clipCompositeLayer(layer)));
     return clippedLayers.filter((layer) => Boolean(layer));
@@ -608,7 +878,8 @@ function fitLinesToBlock(text, blockWidth, 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) {
+    while ((lines.length > 6 || longestLine(lines) > maxChars + 1) &&
+        fontSize > 34) {
         fontSize -= 3;
         lineHeight = pickLineHeight(fontSize, fontId);
         maxChars = approximateMaxChars(blockWidth, fontSize);
@@ -651,19 +922,19 @@ function pickFontSize(text, fontId) {
 }
 function pickLineHeight(fontSize, fontId) {
     if (fontId === "yesteryear") {
-        return Math.round(fontSize * 0.88);
+        return Math.round(fontSize * 1.04);
     }
     if (fontId === "dm_serif_display") {
-        return Math.round(fontSize * 0.98);
+        return Math.round(fontSize * 1.08);
     }
-    return Math.round(fontSize * 0.94);
+    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 buildLineLayers(input) {
     const lineTop = input.blockY + input.lineIndex * input.lineHeight;
-    const shadowPadding = 24;
+    const shadowPadding = 40;
     const fontAsset = overlayFonts[input.textStyle.fontId];
     const measured = await renderTrimmedTextBuffer({
         text: input.line,
@@ -672,7 +943,7 @@ async function buildLineLayers(input) {
         fontSize: input.fontSize,
         fontFamily: input.textStyle.fontFamily,
         fontPath: fontAsset.path,
-        color: "#ffffff"
+        color: "#ffffff",
     });
     const lineLeft = input.layout.align === "center"
         ? input.blockX + Math.round((input.blockWidth - measured.width) / 2)
@@ -684,12 +955,12 @@ async function buildLineLayers(input) {
         const chip = await buildTextChip({
             width: measured.width,
             height: measured.height,
-            fill: input.textStyle.backgroundColorHex
+            fill: input.textStyle.backgroundColorHex,
         });
         layers.push({
             input: chip,
             left: lineLeft - 14,
-            top: lineTop - 8
+            top: lineTop - 8,
         });
     }
     const shadowFar = await renderShadowLayer({
@@ -697,16 +968,24 @@ async function buildLineLayers(input) {
         width: measured.width,
         height: measured.height,
         shadowPadding,
-        blur: 3.1
+        blur: 8,
     });
     const shadowNear = await renderShadowLayer({
         textBuffer: measured.buffer,
         width: measured.width,
         height: measured.height,
         shadowPadding,
-        blur: 1.15
+        blur: 2.4,
     });
-    layers.push({ input: shadowFar, left: lineLeft - shadowPadding, top: lineTop - shadowPadding + 2 }, { input: shadowNear, left: lineLeft - shadowPadding, top: lineTop - shadowPadding + 1 }, { input: measured.buffer, left: lineLeft, top: lineTop });
+    layers.push({
+        input: shadowFar,
+        left: lineLeft - shadowPadding,
+        top: lineTop - shadowPadding + 8,
+    }, {
+        input: shadowNear,
+        left: lineLeft - shadowPadding,
+        top: lineTop - shadowPadding + 4,
+    }, { input: measured.buffer, left: lineLeft, top: lineTop });
     return layers;
 }
 async function renderTrimmedTextBuffer(input) {
@@ -720,8 +999,8 @@ async function renderTrimmedTextBuffer(input) {
             align: "left",
             spacing: 0,
             font: `${input.fontFamily} ${input.fontSize}`,
-            fontfile: input.fontPath
-        }
+            fontfile: input.fontPath,
+        },
     })
         .trim()
         .png()
@@ -730,7 +1009,7 @@ async function renderTrimmedTextBuffer(input) {
     return {
         buffer: rendered,
         width: metadata.width ?? input.blockWidth,
-        height: metadata.height ?? input.lineHeight
+        height: metadata.height ?? input.lineHeight,
     };
 }
 async function renderShadowLayer(input) {
@@ -739,10 +1018,16 @@ async function renderShadowLayer(input) {
             width: input.width + input.shadowPadding * 2,
             height: input.height + input.shadowPadding * 2,
             channels: 4,
-            background: { r: 0, g: 0, b: 0, alpha: 0 }
-        }
+            background: { r: 0, g: 0, b: 0, alpha: 0 },
+        },
     })
-        .composite([{ input: input.textBuffer, left: input.shadowPadding, top: input.shadowPadding }])
+        .composite([
+        {
+            input: input.textBuffer,
+            left: input.shadowPadding,
+            top: input.shadowPadding,
+        },
+    ])
         .modulate({ brightness: 0 })
         .linear(0, 0)
         .blur(input.blur)
@@ -793,7 +1078,8 @@ async function portraitScore(input) {
         .raw()
         .toBuffer();
     const edgeContrast = edgeBandContrast(sample, thumbnailWidth, thumbnailHeight);
-    return Math.abs(aspect - (9 / 16)) + edgeContrast;
+    const edgeFlatnessPenalty = edgeBandFlatnessPenalty(sample, thumbnailWidth, thumbnailHeight);
+    return Math.abs(aspect - 9 / 16) + edgeContrast + edgeFlatnessPenalty;
 }
 async function chooseLayoutFromImage(imageBytes, overlayText) {
     const thumbnailWidth = 108;
@@ -809,7 +1095,8 @@ async function chooseLayoutFromImage(imageBytes, overlayText) {
     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;
+        const score = scoreLayoutRegion(sample, thumbnailWidth, thumbnailHeight, region) +
+            candidate.stylePenalty;
         if (score < bestScore) {
             best = candidate;
             bestScore = score;
@@ -821,7 +1108,7 @@ async function chooseLayoutFromImage(imageBytes, overlayText) {
         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.`
+        justification: `${best.justification} Selected by local safe-zone scoring to minimize busy backgrounds and avoid TikTok UI chrome.`,
     };
 }
 async function chooseSlideLayout(ctx, input) {
@@ -831,7 +1118,7 @@ async function chooseSlideLayout(ctx, input) {
                 provider: input.provider,
                 model: input.model,
                 imageUrl: input.imageUrl,
-                overlayText: input.overlayText
+                overlayText: input.overlayText,
             });
             return normalizeAiLayout(analysis);
         }
@@ -839,7 +1126,7 @@ async function chooseSlideLayout(ctx, input) {
             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)
+                message: error instanceof Error ? error.message : String(error),
             });
         }
     }
@@ -852,28 +1139,28 @@ function normalizeAiLayout(input) {
         : normalizedAlign === "left"
             ? 0.38
             : 0.62;
-    const anchorYPercent = input.zone === "top"
-        ? 0.18
-        : input.zone === "bottom"
-            ? 0.38
-            : 0.28;
+    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.`
+        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 blockWidth = Math.round(safeWidth * clamp(layout.maxWidthPercent / 100, 0.4, 0.62));
+    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
+        fontSize,
     };
 }
 function regionForLayout(layout, blockWidth, blockHeight) {
@@ -882,18 +1169,25 @@ function regionForLayout(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;
-    if (layout.anchorXPercent !== undefined && layout.anchorYPercent !== undefined) {
+    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: 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)),
+            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
+            height: blockHeight,
         };
     }
     const x = layout.align === "left"
         ? TIKTOK_SAFE_AREA.left
         : layout.align === "center"
-            ? TIKTOK_SAFE_AREA.left + Math.round((safeWidth - blockWidth) / 2)
+            ? 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
@@ -904,7 +1198,17 @@ function resolveTextBlockRect(layout, blockWidth, blockHeight) {
         left: x,
         top: y,
         width: blockWidth,
-        height: blockHeight
+        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) {
@@ -947,8 +1251,8 @@ function sampleStats(sample, width, height, region, padding) {
             }
             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;
+            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);
@@ -960,7 +1264,7 @@ function sampleStats(sample, width, height, region, padding) {
     return {
         mean,
         variance,
-        detail: detail / Math.max(count, 1)
+        detail: detail / Math.max(count, 1),
     };
 }
 function edgeBandContrast(sample, width, height) {
@@ -969,6 +1273,23 @@ function edgeBandContrast(sample, width, height) {
     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;
@@ -1011,11 +1332,14 @@ async function clipCompositeLayer(layer) {
     if (cropWidth <= 0 || cropHeight <= 0) {
         return null;
     }
-    if (cropLeft === 0 && cropTop === 0 && cropWidth === width && cropHeight === height) {
+    if (cropLeft === 0 &&
+        cropTop === 0 &&
+        cropWidth === width &&
+        cropHeight === height) {
         return {
             input: layer.input,
             left,
-            top
+            top,
         };
     }
     const input = await sharp(layer.input)
@@ -1023,20 +1347,22 @@ async function clipCompositeLayer(layer) {
         left: cropLeft,
         top: cropTop,
         width: cropWidth,
-        height: cropHeight
+        height: cropHeight,
     })
         .png()
         .toBuffer();
     return {
         input,
         left,
-        top
+        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 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) {
@@ -1049,7 +1375,8 @@ function buildLayoutCandidates(overlayText) {
                     anchorXPercent,
                     anchorYPercent,
                     justification: "Image-aware centered native TikTok caption zone.",
-                    stylePenalty: scoreNativeUiAnchor(anchorXPercent, anchorYPercent) + (prefersCenteredText ? 0 : 4)
+                    stylePenalty: scoreNativeUiAnchor(anchorXPercent, anchorYPercent) +
+                        (prefersCenteredText ? 0 : 4),
                 });
             }
         }
@@ -1058,10 +1385,12 @@ function buildLayoutCandidates(overlayText) {
 }
 function scoreNativeUiAnchor(anchorXPercent, anchorYPercent) {
     let penalty = 0;
-    if (anchorXPercent < NATIVE_UI_TEXT_ZONE.minCenterXPercent || anchorXPercent > NATIVE_UI_TEXT_ZONE.maxCenterXPercent) {
+    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) {
+    if (anchorYPercent < NATIVE_UI_TEXT_ZONE.minCenterYPercent ||
+        anchorYPercent > NATIVE_UI_TEXT_ZONE.maxCenterYPercent) {
         penalty += 10;
     }
     penalty += Math.abs(anchorXPercent - 0.5) * 24;
@@ -1075,23 +1404,18 @@ function resolveRemotionEntryPoint() {
     }
     return fileURLToPath(new URL("./remotion/index.tsx", import.meta.url));
 }
-function resolveTemplateRemotionRuntimeConfig() {
+function resolveTemplateRuntimeConfig() {
     const candidates = [
         fileURLToPath(new URL("../template.config.json", import.meta.url)),
-        path.resolve(process.cwd(), "templates/template_0000/template.config.json")
+        path.resolve(process.cwd(), "templates/template_0000/template.config.json"),
     ];
     for (const candidate of candidates) {
         if (!existsSync(candidate)) {
             continue;
         }
-        const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-        return {
-            serveUrl: parsed.remotion?.serve_url ?? undefined
-        };
+        return JSON.parse(readFileSync(candidate, "utf8"));
     }
-    return {
-        serveUrl: undefined
-    };
+    return {};
 }
 function resolveSkillPath() {
     const builtPath = fileURLToPath(new URL("../SKILL.md", import.meta.url));
@@ -1104,7 +1428,7 @@ function resolveOverlayFonts() {
     const resolved = Object.fromEntries(TEMPLATE_FONT_OPTIONS.map((option) => {
         const candidates = [
             fileURLToPath(new URL(`../assets/${option.assetFile}`, import.meta.url)),
-            path.resolve(process.cwd(), `templates/template_0000/assets/${option.assetFile}`)
+            path.resolve(process.cwd(), `templates/template_0000/assets/${option.assetFile}`),
         ];
         for (const candidate of candidates) {
             if (existsSync(candidate)) {