@mevdragon/vidfarm-devcli 0.2.2 → 0.2.3

package/dist/src/services/template-sources.js

@@ -5,6 +5,7 @@ import { promisify } from "node:util";
 import { config } from "../config.js";
 import { database } from "../db.js";
 import { createId } from "../lib/ids.js";
+import { defaultSkillPathForTemplateModule, deriveTemplateRootDirFromModulePath } from "../lib/template-paths.js";
 import { nowIso } from "../lib/time.js";
 import { loadTemplateFromModule } from "./template-loader.js";
 import { TemplateCertificationService } from "./template-certification.js";
@@ -18,6 +19,7 @@ export class TemplateSourceService {
         return database.listTemplateReleases(templateId);
     }
     registerSource(input) {
+        deriveTemplateRootDirFromModulePath(input.templateModulePath);
         const existingByTemplateId = database.getTemplateSourceByTemplateId(input.templateId);
         if (existingByTemplateId) {
             throw new Error("A template with this template_id already exists. Generate a new UUIDv4 and try again.");
@@ -33,7 +35,7 @@ export class TemplateSourceService {
             repoUrl: input.repoUrl,
             branch: input.branch ?? "production",
             templateModulePath: input.templateModulePath,
-            skillPath: input.skillPath ?? "SKILL.md",
+            skillPath: input.skillPath ?? defaultSkillPathForTemplateModule(input.templateModulePath),
             installCommand: input.installCommand ?? "npm install",
             buildCommand: input.buildCommand ?? "npm run build",
             status: "active"
@@ -47,7 +49,6 @@ export class TemplateSourceService {
         const commitSha = input.commitSha ?? await this.resolveBranchHead(source.repoUrl, source.branch);
         const checkoutPath = path.join(config.TEMPLATE_SOURCE_ROOT, source.templateId, commitSha);
         const skillPath = path.join(checkoutPath, source.skillPath);
-        const modulePath = path.join(checkoutPath, source.templateModulePath);
         if (!existsSync(checkoutPath)) {
             mkdirSync(path.dirname(checkoutPath), { recursive: true });
             await this.runShell(["git", "clone", "--branch", source.branch, source.repoUrl, checkoutPath], process.cwd());
@@ -59,6 +60,7 @@ export class TemplateSourceService {
                 await this.runCommandString(source.buildCommand, checkoutPath);
             }
         }
+        const modulePath = this.resolveImportableModulePath(checkoutPath, source.templateModulePath);
         const template = await loadTemplateFromModule(modulePath);
         if (template.id !== source.templateId) {
             throw new Error(`Imported template id ${template.id} does not match source template id ${source.templateId}.`);
@@ -130,6 +132,30 @@ export class TemplateSourceService {
         await execFileAsync(args[0], args.slice(1), { cwd });
     }
     async runCommandString(command, cwd) {
-        await execFileAsync("/bin/sh", ["-lc", command], { cwd });
+        await execFileAsync("/bin/sh", ["-lc", command], {
+            cwd,
+            env: {
+                ...process.env,
+                NODE_ENV: "development",
+                npm_config_production: "false",
+                NPM_CONFIG_PRODUCTION: "false",
+                NPM_CONFIG_INCLUDE: "dev"
+            }
+        });
+    }
+    resolveImportableModulePath(checkoutPath, declaredModulePath) {
+        const sourceModulePath = path.join(checkoutPath, declaredModulePath);
+        const extension = path.extname(sourceModulePath).toLowerCase();
+        if (extension === ".ts" || extension === ".tsx") {
+            const compiledModulePath = sourceModulePath.replace(/\.(ts|tsx)$/i, ".js");
+            if (existsSync(compiledModulePath)) {
+                return compiledModulePath;
+            }
+            throw new Error(`Template module path ${declaredModulePath} is TypeScript, but the compiled module ${path.relative(checkoutPath, compiledModulePath)} was not found after build.`);
+        }
+        if (existsSync(sourceModulePath)) {
+            return sourceModulePath;
+        }
+        throw new Error(`Template module path ${declaredModulePath} was not found in the imported release.`);
     }
 }

package/dist/templates/template_0000/src/lib/images.js

@@ -4,25 +4,60 @@ export async function normalizeToPortraitFrame(input, target = { width: 1080, he
     const oriented = sharp(buffer, { density: 144 }).rotate();
     const trimmed = await trimFlatBorders(oriented);
     const targetAspect = target.width / target.height;
-    // If the model already returned a near-native vertical frame, avoid the
-    // activity crop pass because it can misread low-detail edges as padding.
     const shouldPreserveFraming = await isCloseToAspect(trimmed, targetAspect, 0.025);
     const cropped = shouldPreserveFraming ? trimmed : await cropToActiveImageRegion(trimmed);
-    const portraitCrop = await cropToPortraitAspect(cropped, targetAspect);
-    const output = await portraitCrop
+    const normalized = await resizeWithBlurredContain(cropped, target, targetAspect);
+    return {
+        bytes: normalized,
+        contentType: "image/png",
+        width: target.width,
+        height: target.height
+    };
+}
+async function resizeWithBlurredContain(image, target, targetAspect) {
+    const metadata = await image.metadata();
+    const width = metadata.width ?? 0;
+    const height = metadata.height ?? 0;
+    if (!width || !height) {
+        return image
+            .resize(target.width, target.height, {
+            fit: "cover",
+            position: sharp.strategy.attention
+        })
+            .png()
+            .toBuffer();
+    }
+    const aspect = width / height;
+    if (Math.abs(aspect - targetAspect) <= 0.015) {
+        return image
+            .resize(target.width, target.height, {
+            fit: "fill"
+        })
+            .png()
+            .toBuffer();
+    }
+    const foreground = await image
+        .clone()
+        .resize(target.width, target.height, {
+        fit: "contain",
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+    })
+        .png()
+        .toBuffer();
+    const background = await image
+        .clone()
         .resize(target.width, target.height, {
         fit: "cover",
         position: sharp.strategy.attention
     })
+        .blur(20)
+        .modulate({ brightness: 0.92, saturation: 0.9 })
+        .png()
+        .toBuffer();
+    return sharp(background)
+        .composite([{ input: foreground }])
         .png()
         .toBuffer();
-    const exact = await ensureExactPixelSize(output, target);
-    return {
-        bytes: exact,
-        contentType: "image/png",
-        width: target.width,
-        height: target.height
-    };
 }
 async function isCloseToAspect(image, targetAspect, tolerance) {
     const metadata = await image.metadata();
@@ -77,27 +112,6 @@ async function cropToActiveImageRegion(image) {
     const height = Math.min(sourceHeight - top, Math.max(1, Math.ceil((bounds.height / sampleHeight) * sourceHeight)));
     return image.extract({ left, top, width, height });
 }
-async function cropToPortraitAspect(image, targetAspect) {
-    const metadata = await image.metadata();
-    const sourceWidth = metadata.width ?? 0;
-    const sourceHeight = metadata.height ?? 0;
-    if (!sourceWidth || !sourceHeight) {
-        return image;
-    }
-    const sourceAspect = sourceWidth / sourceHeight;
-    if (Math.abs(sourceAspect - targetAspect) < 0.015) {
-        return image;
-    }
-    const focus = await detectFocusPoint(image, sourceWidth, sourceHeight);
-    if (sourceAspect > targetAspect) {
-        const cropWidth = Math.max(1, Math.min(sourceWidth, Math.round(sourceHeight * targetAspect)));
-        const left = clamp(Math.round(focus.x - cropWidth / 2), 0, sourceWidth - cropWidth);
-        return image.extract({ left, top: 0, width: cropWidth, height: sourceHeight });
-    }
-    const cropHeight = Math.max(1, Math.min(sourceHeight, Math.round(sourceWidth / targetAspect)));
-    const top = clamp(Math.round(focus.y - cropHeight / 2), 0, sourceHeight - cropHeight);
-    return image.extract({ left: 0, top, width: sourceWidth, height: cropHeight });
-}
 function detectActiveBounds(sample, width, height) {
     const rowActivity = new Array(height).fill(0);
     const colActivity = new Array(width).fill(0);
@@ -142,46 +156,6 @@ function detectActiveBounds(sample, width, height) {
         height: croppedHeight
     };
 }
-async function detectFocusPoint(image, sourceWidth, sourceHeight) {
-    const sampleWidth = 120;
-    const sampleHeight = Math.max(1, Math.round((sourceHeight / Math.max(sourceWidth, 1)) * sampleWidth));
-    const sample = await image
-        .clone()
-        .resize(sampleWidth, sampleHeight, { fit: "fill" })
-        .grayscale()
-        .raw()
-        .toBuffer();
-    let weightedX = 0;
-    let weightedY = 0;
-    let totalWeight = 0;
-    for (let y = 0; y < sampleHeight; y += 1) {
-        for (let x = 0; x < sampleWidth; x += 1) {
-            const index = y * sampleWidth + x;
-            const current = sample[index] ?? 0;
-            const left = x > 0 ? sample[index - 1] ?? current : current;
-            const up = y > 0 ? sample[index - sampleWidth] ?? current : current;
-            const right = x < sampleWidth - 1 ? sample[index + 1] ?? current : current;
-            const down = y < sampleHeight - 1 ? sample[index + sampleWidth] ?? current : current;
-            const energy = Math.abs(current - left) +
-                Math.abs(current - right) +
-                Math.abs(current - up) +
-                Math.abs(current - down);
-            const centerBiasX = 1 - Math.abs((x + 0.5) / sampleWidth - 0.5) * 0.45;
-            const centerBiasY = 1 - Math.abs((y + 0.5) / sampleHeight - 0.5) * 0.35;
-            const weight = Math.max(energy, 1) * centerBiasX * centerBiasY;
-            weightedX += (x + 0.5) * weight;
-            weightedY += (y + 0.5) * weight;
-            totalWeight += weight;
-        }
-    }
-    if (totalWeight <= 0) {
-        return { x: sourceWidth / 2, y: sourceHeight / 2 };
-    }
-    return {
-        x: (weightedX / totalWeight / sampleWidth) * sourceWidth,
-        y: (weightedY / totalWeight / sampleHeight) * sourceHeight
-    };
-}
 function findActiveRange(values, minSpan) {
     const mean = values.reduce((sum, value) => sum + value, 0) / Math.max(values.length, 1);
     const max = values.reduce((best, value) => Math.max(best, value), 0);
@@ -226,17 +200,3 @@ function smoothSeries(values, radius) {
 function clamp(value, min, max) {
     return Math.min(Math.max(value, min), max);
 }
-async function ensureExactPixelSize(input, target) {
-    const metadata = await sharp(input).metadata();
-    if (metadata.width === target.width && metadata.height === target.height) {
-        return input;
-    }
-    const exactCrop = await cropToPortraitAspect(sharp(input), target.width / target.height);
-    return exactCrop
-        .resize(target.width, target.height, {
-        fit: "cover",
-        position: sharp.strategy.attention
-    })
-        .png()
-        .toBuffer();
-}

package/dist/templates/template_0000/src/template.js

@@ -27,6 +27,31 @@ const NATIVE_UI_TEXT_ZONE = {
     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([
@@ -132,29 +157,43 @@ export const template0000Definition = defineTemplate({
             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, {
@@ -192,6 +231,8 @@ export const template0000Definition = defineTemplate({
                 });
                 slides.push({
                     index,
+                    sourceType,
+                    sourceValue,
                     imagePrompt,
                     imagePromptAttachments,
                     overlayText,
@@ -207,6 +248,8 @@ export const template0000Definition = defineTemplate({
             const metaDetails = await generateMetaDetails(ctx, {
                 provider,
                 textModel,
+                configuredProvider: provider,
+                configuredTextModel,
                 slides,
                 metaDetailsPrompt: payload.meta_details_prompt,
             });
@@ -254,6 +297,8 @@ 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,
@@ -374,26 +419,43 @@ async function generatePortraitCandidateImage(ctx, input) {
         ].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;
 }
@@ -419,7 +481,7 @@ function isImageProvider(value) {
 }
 function sourceImageSizeForProvider(provider) {
     if (provider === "openai") {
-        return "1024x1792";
+        return "1024x1536";
     }
     return "1080x1920";
 }
@@ -430,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") {
@@ -448,12 +510,29 @@ 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
@@ -532,6 +611,8 @@ const slideshowManifestSchema = z.object({
     }),
     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(),
@@ -552,29 +633,154 @@ const slideshowManifestSchema = z.object({
 });
 function normalizeSlideInput(input) {
     if (Array.isArray(input)) {
-        return {
-            imagePrompt: input[0],
+        return normalizeSlideFields({
+            primarySource: input[0],
             imagePromptAttachments: [],
             overlayText: input[1],
             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,
+    });
+}
+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 [
@@ -872,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;
@@ -1066,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;