@mevdragon/vidfarm-devcli 0.2.7 → 0.2.9

package/dist/src/services/rate-limits.js

@@ -0,0 +1,236 @@
+import { DynamoDBClient, GetItemCommand, TransactWriteItemsCommand } from "@aws-sdk/client-dynamodb";
+import { config } from "../config.js";
+const dynamodb = new DynamoDBClient({});
+const OPERATIONS_TABLE_NAME = config.VIDFARM_RATE_LIMITS_TABLE_NAME?.trim() || "";
+const REST_LIMIT_SUMMARY = "General REST API limits: max 10 requests per second, 300 requests per minute, and 5000 requests per hour.";
+export class RateLimitExceededError extends Error {
+    type;
+    status;
+    constructor(message, type, status) {
+        super(message);
+        this.type = type;
+        this.status = status;
+    }
+}
+const OPERATION_LIMITS = {
+    starter: {
+        month: 750,
+        week: 400,
+        five_hour: 200
+    },
+    standard: {
+        month: 2500,
+        week: 1250,
+        five_hour: 500
+    },
+    agency: {
+        month: 10_000,
+        week: 5_000,
+        five_hour: 2_000
+    }
+};
+const REST_LIMITS = {
+    second: 10,
+    minute: 300,
+    hour: 5_000
+};
+const WINDOW_DEFINITIONS = {
+    month: { durationMs: 30 * 24 * 60 * 60 * 1000, label: "30-day window" },
+    week: { durationMs: 7 * 24 * 60 * 60 * 1000, label: "7-day window" },
+    five_hour: { durationMs: 5 * 60 * 60 * 1000, label: "5-hour window" },
+    second: { durationMs: 1000, label: "1-second window" },
+    minute: { durationMs: 60 * 1000, label: "1-minute window" },
+    hour: { durationMs: 60 * 60 * 1000, label: "1-hour window" }
+};
+export class RateLimitService {
+    isConfigured() {
+        return Boolean(OPERATIONS_TABLE_NAME);
+    }
+    async consumeTemplateOperation(customer) {
+        if (!this.isConfigured()) {
+            return;
+        }
+        await this.consumeWindows({
+            scopePk: `customer#${customer.id}`,
+            scopeLabel: `customer:${customer.id}`,
+            anchorMs: new Date(customer.createdAt).getTime(),
+            limits: OPERATION_LIMITS[customer.planTier],
+            type: "operation_rate_limit_exceeded"
+        });
+    }
+    async consumeGeneralRest(scopeId) {
+        if (!this.isConfigured()) {
+            return;
+        }
+        const statuses = await this.consumeWindows({
+            scopePk: `rest#${scopeId}`,
+            scopeLabel: scopeId,
+            anchorMs: 0,
+            limits: REST_LIMITS,
+            type: "rest_rate_limit_exceeded"
+        });
+        const violations = statuses.filter((status) => status.used > status.limit);
+        if (violations.length > 0) {
+            throw new RateLimitExceededError(violations[0].message, "rest_rate_limit_exceeded", violations);
+        }
+    }
+    async getTemplateOperationStatus(customer) {
+        if (!this.isConfigured()) {
+            return {
+                monthly: this.buildDisabledStatus("month", "30-day window"),
+                weekly: this.buildDisabledStatus("week", "7-day window"),
+                five_hour: this.buildDisabledStatus("five_hour", "5-hour window")
+            };
+        }
+        const statuses = await this.readWindows({
+            scopePk: `customer#${customer.id}`,
+            scopeLabel: `customer:${customer.id}`,
+            anchorMs: new Date(customer.createdAt).getTime(),
+            limits: OPERATION_LIMITS[customer.planTier]
+        });
+        const mapped = this.buildOperationStatuses(statuses);
+        return {
+            monthly: mapped.find((status) => status.key === "month"),
+            weekly: mapped.find((status) => status.key === "week"),
+            five_hour: mapped.find((status) => status.key === "five_hour")
+        };
+    }
+    getRestSummary() {
+        return {
+            message: REST_LIMIT_SUMMARY,
+            limits: {
+                per_second: REST_LIMITS.second,
+                per_minute: REST_LIMITS.minute,
+                per_hour: REST_LIMITS.hour
+            }
+        };
+    }
+    async consumeWindows(input) {
+        const windowSpecs = this.buildWindowSpecs(input.anchorMs, input.limits);
+        let transactionCancelled = false;
+        try {
+            await dynamodb.send(new TransactWriteItemsCommand({
+                TransactItems: windowSpecs.map((spec) => ({
+                    Update: {
+                        TableName: OPERATIONS_TABLE_NAME,
+                        Key: {
+                            pk: { S: input.scopePk },
+                            sk: { S: spec.sk }
+                        },
+                        UpdateExpression: "SET usage_count = if_not_exists(usage_count, :zero) + :one, #scope = if_not_exists(#scope, :scope), window_key = if_not_exists(window_key, :windowKey), window_started_at = if_not_exists(window_started_at, :windowStartedAt), window_ends_at = if_not_exists(window_ends_at, :windowEndsAt), limit_value = if_not_exists(limit_value, :limitValue), created_at = if_not_exists(created_at, :createdAt), updated_at = :updatedAt, expires_at_epoch_seconds = if_not_exists(expires_at_epoch_seconds, :ttl)",
+                        ConditionExpression: "attribute_not_exists(usage_count) OR usage_count < :limitValue",
+                        ExpressionAttributeNames: {
+                            "#scope": "scope",
+                        },
+                        ExpressionAttributeValues: {
+                            ":zero": { N: "0" },
+                            ":one": { N: "1" },
+                            ":scope": { S: input.scopeLabel },
+                            ":windowKey": { S: spec.key },
+                            ":windowStartedAt": { S: spec.windowStartedAt },
+                            ":windowEndsAt": { S: spec.nextAvailableAt },
+                            ":limitValue": { N: String(spec.limit) },
+                            ":createdAt": { S: new Date().toISOString() },
+                            ":updatedAt": { S: new Date().toISOString() },
+                            ":ttl": { N: String(Math.floor((new Date(spec.nextAvailableAt).getTime() + (2 * 24 * 60 * 60 * 1000)) / 1000)) }
+                        }
+                    }
+                }))
+            }));
+        }
+        catch (error) {
+            if (!isTransactionCanceledError(error)) {
+                throw error;
+            }
+            transactionCancelled = true;
+        }
+        const statuses = await this.readWindows({
+            scopePk: input.scopePk,
+            scopeLabel: input.scopeLabel,
+            anchorMs: input.anchorMs,
+            limits: input.limits
+        });
+        const violations = statuses.filter((status) => transactionCancelled ? status.used >= status.limit : status.used > status.limit);
+        if (violations.length > 0) {
+            throw new RateLimitExceededError(violations[0].message, input.type, violations);
+        }
+        return statuses;
+    }
+    async readWindows(input) {
+        const windowSpecs = this.buildWindowSpecs(input.anchorMs, input.limits);
+        const items = await Promise.all(windowSpecs.map(async (spec) => {
+            const response = await dynamodb.send(new GetItemCommand({
+                TableName: OPERATIONS_TABLE_NAME,
+                Key: {
+                    pk: { S: input.scopePk },
+                    sk: { S: spec.sk }
+                },
+                ConsistentRead: true
+            }));
+            return this.toStatus(spec, response.Item);
+        }));
+        return items;
+    }
+    buildOperationStatuses(statuses) {
+        return statuses.map((status) => ({
+            ...status,
+            key: status.key === "month" ? "month" : status.key === "week" ? "week" : "five_hour"
+        }));
+    }
+    buildWindowSpecs(anchorMs, limits) {
+        return Object.keys(limits).map((typedKey) => {
+            const limit = limits[typedKey];
+            const definition = WINDOW_DEFINITIONS[typedKey];
+            const nowMs = Date.now();
+            const effectiveAnchorMs = Number.isFinite(anchorMs) && anchorMs > 0 ? anchorMs : 0;
+            const elapsedMs = Math.max(0, nowMs - effectiveAnchorMs);
+            const windowIndex = Math.floor(elapsedMs / definition.durationMs);
+            const windowStartedAtMs = effectiveAnchorMs + (windowIndex * definition.durationMs);
+            const nextAvailableAtMs = windowStartedAtMs + definition.durationMs;
+            const windowStartedAt = new Date(windowStartedAtMs).toISOString();
+            const nextAvailableAt = new Date(nextAvailableAtMs).toISOString();
+            return {
+                key: typedKey,
+                label: definition.label,
+                limit,
+                sk: `${typedKey}#${windowStartedAt}`,
+                windowStartedAt,
+                nextAvailableAt
+            };
+        });
+    }
+    toStatus(spec, item) {
+        const used = Number(item?.usage_count?.N ?? "0");
+        const remaining = Math.max(0, spec.limit - used);
+        const consumedPercent = spec.limit > 0 ? Math.min(100, Number(((used / spec.limit) * 100).toFixed(2))) : 100;
+        return {
+            key: spec.key,
+            label: spec.label,
+            limit: spec.limit,
+            used,
+            remaining,
+            consumedPercent,
+            windowStartedAt: item?.window_started_at?.S ?? spec.windowStartedAt,
+            nextAvailableAt: item?.window_ends_at?.S ?? spec.nextAvailableAt,
+            message: used >= spec.limit
+                ? `Rate limit reached for the ${spec.label}. Usage resets at ${item?.window_ends_at?.S ?? spec.nextAvailableAt}.`
+                : `${used} of ${spec.limit} requests used in the ${spec.label}. Resets at ${item?.window_ends_at?.S ?? spec.nextAvailableAt}.`
+        };
+    }
+    buildDisabledStatus(key, label) {
+        return {
+            key,
+            label,
+            limit: 0,
+            used: 0,
+            remaining: 0,
+            consumedPercent: 0,
+            windowStartedAt: new Date(0).toISOString(),
+            nextAvailableAt: new Date(0).toISOString(),
+            message: "Rate limiting is not configured for this environment."
+        };
+    }
+}
+function isTransactionCanceledError(error) {
+    return error instanceof Error && error.name === "TransactionCanceledException";
+}

package/dist/src/services/remotion.js

@@ -2,41 +2,78 @@ import { mkdirSync } from "node:fs";
 import path from "node:path";
 import { bundle } from "@remotion/bundler";
 import { getRenderProgress, renderMediaOnLambda } from "@remotion/lambda";
-import { getCompositions, renderMedia } from "@remotion/renderer";
+import { getCompositions, renderMedia, renderStill } from "@remotion/renderer";
 import { config } from "../config.js";
 import { createId } from "../lib/ids.js";
+const REQUIRED_VIDEO_FPS = 30;
+const RENDER_MARKUP_MULTIPLIER = 1.2;
 export class RemotionService {
     async render(input) {
-        if ((config.REMOTION_MODE === "local" || (config.REMOTION_MODE === "auto" && input.entryPoint)) && input.entryPoint) {
+        const fps = input.fps ?? REQUIRED_VIDEO_FPS;
+        if (fps !== REQUIRED_VIDEO_FPS) {
+            throw new Error(`Vidfarm renders must be ${REQUIRED_VIDEO_FPS}fps. Received ${fps}fps.`);
+        }
+        const serveUrl = nonBlank(input.serveUrl) ??
+            nonBlank(config.REMOTION_SERVE_URL) ??
+            inferHostedServeUrl(input.compositionId);
+        const hasHostedLambdaConfig = Boolean(nonBlank(config.REMOTION_FUNCTION_NAME) && serveUrl && nonBlank(config.REMOTION_BUCKET_NAME));
+        if (config.isProduction && config.REMOTION_MODE !== "lambda") {
+            throw new Error("Production video rendering must use lambda mode.");
+        }
+        if (input.entryPoint
+            && (config.REMOTION_MODE === "local"
+                || (config.REMOTION_MODE === "auto" && !hasHostedLambdaConfig)
+                || (!config.isProduction && config.REMOTION_MODE === "auto"))) {
+            if (config.isProduction) {
+                throw new Error("Production video rendering cannot fall back to local mode.");
+            }
             return this.renderLocal({
                 compositionId: input.compositionId,
                 entryPoint: input.entryPoint,
                 outputKey: input.outputKey,
+                fps,
                 inputProps: input.inputProps
             });
         }
-        const serveUrl = input.serveUrl ?? config.REMOTION_SERVE_URL;
-        if (config.REMOTION_MODE === "mock" || !config.REMOTION_FUNCTION_NAME || !serveUrl || !config.REMOTION_BUCKET_NAME) {
+        if (config.REMOTION_MODE === "mock") {
+            if (config.isProduction) {
+                throw new Error("Production video rendering cannot use mock mode.");
+            }
             return {
                 renderId: createId("render"),
                 outputUrl: null,
                 metadata: {
                     mode: "mock",
                     compositionId: input.compositionId,
+                    fps,
                     inputProps: input.inputProps
                 }
             };
         }
+        if (!hasHostedLambdaConfig) {
+            throw new Error(config.isProduction
+                ? "Cloud render is not configured."
+                : "Cloud render is not configured. Set REMOTION_FUNCTION_NAME, REMOTION_SERVE_URL, and REMOTION_BUCKET_NAME, or provide a local entryPoint.");
+        }
+        const hostedServeUrl = serveUrl;
+        const hostedFunctionName = nonBlank(config.REMOTION_FUNCTION_NAME);
+        const hostedBucketName = nonBlank(config.REMOTION_BUCKET_NAME);
+        await this.assertCompositionFps({
+            compositionId: input.compositionId,
+            serveUrl: hostedServeUrl,
+            inputProps: input.inputProps,
+            expectedFps: fps
+        });
         return withRemotionCredentials(async () => {
             const render = await renderMediaOnLambda({
                 region: config.REMOTION_REGION,
-                functionName: config.REMOTION_FUNCTION_NAME,
-                serveUrl,
+                functionName: hostedFunctionName,
+                serveUrl: hostedServeUrl,
                 composition: input.compositionId,
                 inputProps: input.inputProps,
                 codec: "h264",
                 privacy: "public",
-                forceBucketName: config.REMOTION_BUCKET_NAME,
+                forceBucketName: hostedBucketName,
                 forceWidth: 1080,
                 forceHeight: 1920,
                 framesPerLambda: 40,
@@ -47,14 +84,16 @@ export class RemotionService {
             for (;;) {
                 const progress = await getRenderProgress({
                     region: config.REMOTION_REGION,
-                    functionName: config.REMOTION_FUNCTION_NAME,
-                    bucketName: config.REMOTION_BUCKET_NAME,
+                    functionName: hostedFunctionName,
+                    bucketName: hostedBucketName,
                     renderId: render.renderId
                 });
                 if (progress.done) {
                     if (!progress.outputFile) {
-                        throw new Error("Remotion render completed without an output file.");
+                        throw new Error("Cloud render completed without an output file.");
                     }
+                    const estimatedCostUsd = progress.costs.accruedSoFar;
+                    const chargeUsd = roundUsd(estimatedCostUsd * RENDER_MARKUP_MULTIPLIER);
                     return {
                         renderId: render.renderId,
                         outputUrl: progress.outputFile,
@@ -62,14 +101,22 @@ export class RemotionService {
                             mode: "lambda",
                             bucketName: render.bucketName,
                             compositionId: input.compositionId,
+                            fps,
                             serveUrl,
+                            estimatedCostUsd,
+                            chargeUsd,
+                            costDisplay: progress.costs.displayCost,
+                            costCurrency: progress.costs.currency,
+                            costDisclaimer: progress.costs.disclaimer,
+                            estimatedBillingDurationInMilliseconds: progress.estimatedBillingDurationInMilliseconds,
+                            lambdasInvoked: progress.lambdasInvoked,
                             overallProgress: progress.overallProgress,
                             renderSize: progress.renderSize
                         }
                     };
                 }
                 if (Date.now() - startedAt > 10 * 60 * 1000) {
-                    throw new Error("Timed out waiting for Remotion render output.");
+                    throw new Error("Timed out waiting for cloud render output.");
                 }
                 await new Promise((resolve) => setTimeout(resolve, 5000));
             }
@@ -78,13 +125,16 @@ export class RemotionService {
     async renderLocal(input) {
         const renderId = createId("render");
         const bundled = await getOrCreateBundle(input.entryPoint);
-        const compositions = await getCompositions(bundled, {
+        const composition = await this.resolveComposition({
+            source: bundled,
+            compositionId: input.compositionId,
             inputProps: input.inputProps
         });
-        const composition = compositions.find((item) => item.id === input.compositionId);
-        if (!composition) {
-            throw new Error(`Composition ${input.compositionId} not found in ${input.entryPoint}`);
-        }
+        this.assertExpectedFps({
+            compositionId: input.compositionId,
+            actualFps: composition.fps,
+            expectedFps: input.fps
+        });
         const outputKey = input.outputKey ?? `renders/${renderId}.mp4`;
         const outputLocation = path.join(config.VIDFARM_DATA_DIR, "storage", outputKey);
         mkdirSync(path.dirname(outputLocation), { recursive: true });
@@ -103,10 +153,71 @@ export class RemotionService {
                 mode: "local",
                 compositionId: input.compositionId,
                 entryPoint: input.entryPoint,
+                fps: input.fps,
                 outputKey
             }
         };
     }
+    async renderStill(input) {
+        const renderId = createId("render");
+        const bundled = await getOrCreateBundle(input.entryPoint);
+        const composition = await this.resolveComposition({
+            source: bundled,
+            compositionId: input.compositionId,
+            inputProps: input.inputProps
+        });
+        const format = input.imageFormat ?? "png";
+        const extension = format === "jpeg" ? "jpg" : format;
+        const outputKey = input.outputKey ?? `renders/${renderId}.${extension}`;
+        const outputLocation = path.join(config.VIDFARM_DATA_DIR, "storage", outputKey);
+        mkdirSync(path.dirname(outputLocation), { recursive: true });
+        await renderStill({
+            serveUrl: bundled,
+            composition,
+            inputProps: input.inputProps,
+            output: outputLocation,
+            imageFormat: format,
+            overwrite: true
+        });
+        return {
+            renderId,
+            outputUrl: `${config.PUBLIC_BASE_URL}/storage/${encodeURIComponent(outputKey)}`,
+            metadata: {
+                mode: "local_still",
+                compositionId: input.compositionId,
+                entryPoint: input.entryPoint,
+                outputKey,
+                imageFormat: format
+            }
+        };
+    }
+    async assertCompositionFps(input) {
+        const composition = await this.resolveComposition({
+            source: input.serveUrl,
+            compositionId: input.compositionId,
+            inputProps: input.inputProps
+        });
+        this.assertExpectedFps({
+            compositionId: input.compositionId,
+            actualFps: composition.fps,
+            expectedFps: input.expectedFps
+        });
+    }
+    async resolveComposition(input) {
+        const compositions = await getCompositions(input.source, {
+            inputProps: input.inputProps
+        });
+        const composition = compositions.find((item) => item.id === input.compositionId);
+        if (!composition) {
+            throw new Error(`Composition ${input.compositionId} not found in ${input.source}`);
+        }
+        return composition;
+    }
+    assertExpectedFps(input) {
+        if (input.actualFps !== input.expectedFps) {
+            throw new Error(`Composition ${input.compositionId} is ${input.actualFps}fps, but Vidfarm requires ${input.expectedFps}fps output.`);
+        }
+    }
 }
 const bundleCache = new Map();
 function getOrCreateBundle(entryPoint) {
@@ -156,3 +267,19 @@ async function withRemotionCredentials(work) {
         }
     }
 }
+function roundUsd(value) {
+    return Number(value.toFixed(6));
+}
+function nonBlank(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function inferHostedServeUrl(compositionId) {
+    const bucketName = nonBlank(config.REMOTION_BUCKET_NAME);
+    if (!bucketName) {
+        return undefined;
+    }
+    const siteName = nonBlank(config.REMOTION_SITE_NAME) ?? compositionId;
+    const encodedSiteName = siteName.split("/").map(encodeURIComponent).join("/");
+    return `https://${bucketName}.s3.${config.REMOTION_REGION}.amazonaws.com/sites/${encodedSiteName}/index.html`;
+}

package/dist/src/services/storage.js

@@ -15,7 +15,7 @@ export class StorageService {
         mkdirSync(this.localRoot, { recursive: true });
     }
     userAttachmentKey(customerId, attachmentId, fileName) {
-        return joinStorageKey("user", customerId, "attachments", attachmentId, fileName);
+        return joinStorageKey("users", customerId, attachmentId, fileName);
     }
     developerAttachmentKey(customerId, attachmentId, fileName) {
         return joinStorageKey("developer", customerId, "attachments", attachmentId, fileName);
@@ -29,6 +29,12 @@ export class StorageService {
     templateJobKey(templateId, customerId, jobId, key) {
         return joinStorageKey(this.templateJobPrefix(templateId, customerId, jobId), key);
     }
+    primitiveJobPrefix(primitiveId, customerId, jobId) {
+        return joinStorageKey("primitives", primitiveId, "users", customerId, "jobs", jobId);
+    }
+    primitiveJobKey(primitiveId, customerId, jobId, key) {
+        return joinStorageKey(this.primitiveJobPrefix(primitiveId, customerId, jobId), key);
+    }
     templateAboutKey(templateId, assetPath) {
         return joinStorageKey("templates", templateId, "about", assetPath);
     }
@@ -46,8 +52,7 @@ export class StorageService {
                 Bucket: config.AWS_S3_BUCKET,
                 Key: key,
                 Body: value,
-                ContentType: contentType,
-                ACL: publicRead ? "public-read" : undefined
+                ContentType: contentType
             }));
             return { key, url: publicRead ? this.getPublicUrl(key) : await this.createReadUrl(key) };
         }
@@ -84,20 +89,17 @@ export class StorageService {
         if (!this.s3 || !config.AWS_S3_BUCKET) {
             throw new Error("Presigned uploads require S3 storage.");
         }
-        const publicRead = input.publicRead ?? config.s3PublicRead;
         const expiresIn = input.expiresIn ?? 3600;
         const command = new PutObjectCommand({
             Bucket: config.AWS_S3_BUCKET,
             Key: key,
-            ContentType: input.contentType,
-            ACL: publicRead ? "public-read" : undefined
+            ContentType: input.contentType
         });
         return {
             url: await getSignedUrl(this.s3, command, { expiresIn }),
             method: "PUT",
             headers: {
-                "content-type": input.contentType,
-                ...(publicRead ? { "x-amz-acl": "public-read" } : {})
+                "content-type": input.contentType
             },
             expiresIn
         };
@@ -115,6 +117,19 @@ export class StorageService {
         }
         return readFileSync(path.join(this.localRoot, key), "utf8");
     }
+    async readBuffer(key) {
+        if (this.s3 && config.AWS_S3_BUCKET) {
+            const response = await this.s3.send(new GetObjectCommand({
+                Bucket: config.AWS_S3_BUCKET,
+                Key: key
+            }));
+            if (!response.Body) {
+                return null;
+            }
+            return Buffer.from(await response.Body.transformToByteArray());
+        }
+        return readFileSync(path.join(this.localRoot, key));
+    }
     async listKeys(prefix) {
         if (this.s3 && config.AWS_S3_BUCKET) {
             const keys = [];

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

@@ -13,11 +13,20 @@ export class TemplateCertificationService {
             typeof template.about.visual_dna === "string" &&
             Array.isArray(template.about.preview_media) &&
             template.about.preview_media.every((entry) => typeof entry === "string") &&
-            typeof template.about.link_to_original === "string"), "Template must define id, slugId, version, and complete about metadata.", {
+            typeof template.about.link_to_original === "string" &&
+            typeof template.about.proposal_generator === "string" &&
+            typeof template.about.skeleton_prompt === "string" &&
+            template.about.skeleton_prompt.length > 0 &&
+            Array.isArray(template.about.sample_prompts) &&
+            template.about.sample_prompts.every((entry) => typeof entry === "string") &&
+            template.about.sample_prompts.length > 0), "Template must define id, slugId, version, and complete about metadata, including proposal_generator, skeleton_prompt, and sample prompts.", {
             templateId: template.id,
             slugId: template.slugId,
             version: template.version,
-            previewMediaCount: template.about?.preview_media?.length ?? 0
+            previewMediaCount: template.about?.preview_media?.length ?? 0,
+            hasProposalGenerator: typeof template.about?.proposal_generator === "string" && template.about.proposal_generator.length > 0,
+            hasSkeletonPrompt: typeof template.about?.skeleton_prompt === "string" && template.about.skeleton_prompt.length > 0,
+            samplePromptCount: template.about?.sample_prompts?.length ?? 0
         }));
         checks.push(this.check("template.operations", Object.keys(template.operations).length > 0, "Template must define at least one operation."));
         checks.push(this.checkSkill(skillPath));
@@ -80,9 +89,12 @@ function createSmokeContext(templateId) {
             defaultWebhookUrl: null,
             isDeveloper: true,
             isPaidPlan: true,
+            planTier: "standard",
             about: null,
             groupchatUrl: null,
-            flockposterApiKey: null
+            flockposterApiKey: null,
+            createdAt: new Date(0).toISOString(),
+            updatedAt: new Date(0).toISOString()
         },
         templateConfig: {},
         logger: {
@@ -120,10 +132,17 @@ function createSmokeContext(templateId) {
             }
         },
         providers: {
+            listAvailableProviders() {
+                return ["openai", "gemini", "openrouter", "perplexity"];
+            },
             async generateText() {
                 providerCalls += 1;
                 return { text: "certification text", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
             },
+            async generateSpeech() {
+                providerCalls += 1;
+                return { bytes: Uint8Array.from([0, 1, 2, 3]), contentType: "audio/mpeg", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
+            },
             async generateImage() {
                 providerCalls += 1;
                 return { bytes: MOCK_PNG_BYTES, contentType: "image/png", revisedPrompt: null };
@@ -136,6 +155,10 @@ function createSmokeContext(templateId) {
                     maxWidthPercent: 80,
                     justification: "Certification mock layout."
                 };
+            },
+            async transcribeSpeech() {
+                providerCalls += 1;
+                return { text: "certification transcript", usage: { inputTokens: 1, outputTokens: 1, costUsd: 0 } };
             }
         },
         remotion: {

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

@@ -4,11 +4,23 @@ export async function loadTemplateFromModule(modulePath) {
     const candidates = Object.values(loaded);
     for (const candidate of candidates) {
         if (isTemplateDefinition(candidate)) {
-            return candidate;
+            return normalizeTemplateDefinition(candidate);
         }
     }
     throw new Error(`No template definition export found in ${modulePath}`);
 }
+function normalizeTemplateDefinition(template) {
+    return {
+        ...template,
+        about: {
+            ...template.about,
+            // Older runtime template releases may predate prompt metadata fields.
+            proposal_generator: template.about.proposal_generator ?? "",
+            skeleton_prompt: template.about.skeleton_prompt ?? "",
+            sample_prompts: template.about.sample_prompts ?? []
+        }
+    };
+}
 function isTemplateDefinition(value) {
     if (!value || typeof value !== "object") {
         return false;
@@ -20,6 +32,9 @@ function isTemplateDefinition(value) {
     const previewMedia = about && Array.isArray(about.preview_media)
         ? about.preview_media
         : null;
+    const samplePrompts = about && Array.isArray(about.sample_prompts)
+        ? about.sample_prompts
+        : null;
     return (typeof candidate.id === "string" &&
         typeof candidate.slugId === "string" &&
         typeof candidate.version === "string" &&
@@ -31,6 +46,9 @@ function isTemplateDefinition(value) {
         Array.isArray(previewMedia) &&
         previewMedia.every((entry) => typeof entry === "string") &&
         typeof about.link_to_original === "string" &&
+        (typeof about.proposal_generator === "string" || typeof about.proposal_generator === "undefined") &&
+        (typeof about.skeleton_prompt === "string" || typeof about.skeleton_prompt === "undefined") &&
+        (samplePrompts === null || samplePrompts.every((entry) => typeof entry === "string")) &&
         typeof candidate.configSchema === "object" &&
         typeof candidate.operations === "object" &&
         typeof candidate.jobs === "object");