@mevdragon/vidfarm-devcli 0.1.0 → 0.2.0

package/templates/template_0000/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "vidfarm_template_0000",
+  "version": "1.0.0",
+  "private": true,
+  "description": "Standalone Vidfarm template_0000 project for authoring, admin review, and controlled production promotion.",
+  "type": "module",
+  "scripts": {
+    "check": "tsc -p tsconfig.json --noEmit",
+    "build": "tsc -p tsconfig.json",
+    "studio": "remotion studio src/remotion/index.tsx",
+    "admin:create-site": "node ./scripts/create-site.mjs",
+    "admin:render:cloud": "node ./scripts/render-cloud.mjs"
+  },
+  "dependencies": {
+    "@remotion/bundler": "4.0.355",
+    "@remotion/cli": "4.0.355",
+    "@remotion/lambda": "4.0.355",
+    "@remotion/renderer": "4.0.355",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "remotion": "4.0.355",
+    "sharp": "^0.34.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.1",
+    "@types/react": "^18.3.23",
+    "@types/react-dom": "^18.3.7",
+    "typescript": "^5.8.3"
+  }
+}

package/templates/template_0000/research/preview/.gitkeep

@@ -0,0 +1 @@
+

package/templates/template_0000/research/source_notes.md

@@ -0,0 +1,7 @@
+# Source Notes
+
+- original format URL:
+- creator/account:
+- why it wins:
+- what must survive adaptation:
+- what can change for new brands:

package/templates/template_0000/scripts/create-site.mjs

@@ -0,0 +1,27 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const config = JSON.parse(readFileSync(path.join(root, "template.config.json"), "utf8"));
+const remotion = config.remotion;
+
+execFileSync(
+  path.join(root, "node_modules", ".bin", "remotion"),
+  [
+    "lambda",
+    "sites",
+    "create",
+    remotion.entry_point,
+    "--site-name",
+    remotion.site_name,
+    "--region",
+    remotion.region
+  ],
+  {
+    cwd: root,
+    stdio: "inherit",
+    env: process.env
+  }
+);

package/templates/template_0000/scripts/render-cloud.mjs

@@ -0,0 +1,72 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const config = JSON.parse(readFileSync(path.join(root, "template.config.json"), "utf8"));
+const remotion = config.remotion;
+const args = process.argv.slice(2);
+const manifestArgIndex = args.findIndex((value) => value === "--manifest");
+const propsPath = manifestArgIndex >= 0 && args[manifestArgIndex + 1]
+  ? await buildPropsFileFromManifest(args[manifestArgIndex + 1])
+  : remotion.props_file;
+
+execFileSync(
+  path.join(root, "node_modules", ".bin", "remotion"),
+  [
+    "lambda",
+    "render",
+    remotion.serve_url,
+    remotion.composition_id,
+    "--props",
+    propsPath,
+    "--region",
+    remotion.region,
+    "--function-name",
+    remotion.function_name,
+    "--timeout",
+    String(remotion.timeout_ms),
+    "--frames-per-lambda",
+    String(remotion.frames_per_lambda)
+  ],
+  {
+    cwd: root,
+    stdio: "inherit",
+    env: process.env
+  }
+);
+
+async function buildPropsFileFromManifest(manifestInput) {
+  const manifest = await readManifest(manifestInput);
+  const slides = Array.isArray(manifest.slides)
+    ? manifest.slides
+      .map((slide) => slide?.frameImageUrl ? { imageUrl: slide.frameImageUrl } : null)
+      .filter(Boolean)
+    : [];
+
+  if (!slides.length) {
+    throw new Error(`Manifest did not contain any frameImageUrl slides: ${manifestPath}`);
+  }
+
+  const propsPath = path.join(root, ".tmp-render-cloud-props.json");
+  const props = {
+    slides,
+    secondsPerSlide: manifest.secondsPerSlide ?? 4
+  };
+  writeFileSync(propsPath, JSON.stringify(props, null, 2));
+  return propsPath;
+}
+
+async function readManifest(manifestInput) {
+  if (/^https?:\/\//i.test(manifestInput)) {
+    const response = await fetch(manifestInput);
+    if (!response.ok) {
+      throw new Error(`Could not fetch manifest URL ${manifestInput}: ${response.status}`);
+    }
+    return await response.json();
+  }
+
+  const manifestPath = path.isAbsolute(manifestInput) ? manifestInput : path.resolve(process.cwd(), manifestInput);
+  return JSON.parse(readFileSync(manifestPath, "utf8"));
+}

package/templates/template_0000/src/lib/images.ts

@@ -0,0 +1,284 @@
+import sharp from "sharp";
+
+export async function normalizeToPortraitFrame(
+  input: Uint8Array,
+  target = { width: 1080, height: 1920 }
+) {
+  const buffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+  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
+    .resize(target.width, target.height, {
+      fit: "cover",
+      position: sharp.strategy.attention
+    })
+    .png()
+    .toBuffer();
+  const exact = await ensureExactPixelSize(output, target);
+
+  return {
+    bytes: exact,
+    contentType: "image/png" as const,
+    width: target.width,
+    height: target.height
+  };
+}
+
+async function isCloseToAspect(image: sharp.Sharp, targetAspect: number, tolerance: number) {
+  const metadata = await image.metadata();
+  const width = metadata.width ?? 0;
+  const height = metadata.height ?? 0;
+  if (!width || !height) {
+    return false;
+  }
+  return Math.abs(width / height - targetAspect) <= tolerance;
+}
+
+async function trimFlatBorders(image: sharp.Sharp) {
+  const metadata = await image.metadata();
+  const sourceWidth = metadata.width ?? 0;
+  const sourceHeight = metadata.height ?? 0;
+  if (!sourceWidth || !sourceHeight || sourceWidth < 3 || sourceHeight < 3) {
+    return image;
+  }
+
+  const { data, info } = await image
+    .clone()
+    .trim({ threshold: 16 })
+    .png()
+    .toBuffer({ resolveWithObject: true });
+
+  const widthRatio = info.width / sourceWidth;
+  const heightRatio = info.height / sourceHeight;
+  if (widthRatio > 0.985 && heightRatio > 0.985) {
+    return image;
+  }
+
+  return sharp(data).rotate();
+}
+
+async function cropToActiveImageRegion(image: sharp.Sharp) {
+  const metadata = await image.metadata();
+  const sourceWidth = metadata.width ?? 0;
+  const sourceHeight = metadata.height ?? 0;
+  if (!sourceWidth || !sourceHeight) {
+    return image;
+  }
+
+  const sampleWidth = 96;
+  const sampleHeight = 170;
+  const sample = await image
+    .clone()
+    .resize(sampleWidth, sampleHeight, { fit: "fill" })
+    .grayscale()
+    .raw()
+    .toBuffer();
+
+  const bounds = detectActiveBounds(sample, sampleWidth, sampleHeight);
+  if (!bounds) {
+    return image;
+  }
+
+  const left = Math.max(0, Math.floor((bounds.left / sampleWidth) * sourceWidth));
+  const top = Math.max(0, Math.floor((bounds.top / sampleHeight) * sourceHeight));
+  const width = Math.min(sourceWidth - left, Math.max(1, Math.ceil((bounds.width / sampleWidth) * sourceWidth)));
+  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: sharp.Sharp, targetAspect: number) {
+  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: Buffer, width: number, height: number) {
+  const rowActivity = new Array<number>(height).fill(0);
+  const colActivity = new Array<number>(width).fill(0);
+
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const index = y * width + x;
+      const current = sample[index] ?? 0;
+      const left = x > 0 ? sample[index - 1] ?? current : current;
+      const up = y > 0 ? sample[index - width] ?? current : current;
+      const right = x < width - 1 ? sample[index + 1] ?? current : current;
+      const down = y < height - 1 ? sample[index + width] ?? current : current;
+      const energy =
+        Math.abs(current - left) +
+        Math.abs(current - right) +
+        Math.abs(current - up) +
+        Math.abs(current - down);
+      rowActivity[y] += energy;
+      colActivity[x] += energy;
+    }
+  }
+
+  const smoothedRows = smoothSeries(rowActivity.map((value) => value / width), 9);
+  const smoothedCols = smoothSeries(colActivity.map((value) => value / height), 7);
+  const rowBounds = findActiveRange(smoothedRows, Math.round(height * 0.18));
+  const colBounds = findActiveRange(smoothedCols, Math.round(width * 0.16));
+  if (!rowBounds || !colBounds) {
+    return null;
+  }
+
+  const topMargin = rowBounds.start / height;
+  const bottomMargin = (height - rowBounds.end - 1) / height;
+  const leftMargin = colBounds.start / width;
+  const rightMargin = (width - colBounds.end - 1) / width;
+  const croppedWidth = colBounds.end - colBounds.start + 1;
+  const croppedHeight = rowBounds.end - rowBounds.start + 1;
+  const croppedAreaRatio = (croppedWidth * croppedHeight) / (width * height);
+  const significantMargins =
+    topMargin > 0.11 || bottomMargin > 0.11 || leftMargin > 0.08 || rightMargin > 0.08;
+
+  if (!significantMargins && croppedAreaRatio > 0.9) {
+    return null;
+  }
+
+  return {
+    left: colBounds.start,
+    top: rowBounds.start,
+    width: croppedWidth,
+    height: croppedHeight
+  };
+}
+
+async function detectFocusPoint(image: sharp.Sharp, sourceWidth: number, sourceHeight: number) {
+  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: number[], minSpan: number) {
+  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);
+  if (max <= 0) {
+    return null;
+  }
+
+  const threshold = mean + (max - mean) * 0.18;
+  let start = 0;
+  while (start < values.length && values[start] < threshold) {
+    start += 1;
+  }
+
+  let end = values.length - 1;
+  while (end >= 0 && values[end] < threshold) {
+    end -= 1;
+  }
+
+  if (start >= end) {
+    return null;
+  }
+
+  const desiredSpan = Math.max(minSpan, end - start + 1);
+  const extra = desiredSpan - (end - start + 1);
+  const expandStart = Math.floor(extra / 2);
+  const expandEnd = extra - expandStart;
+  start = Math.max(0, start - expandStart - 4);
+  end = Math.min(values.length - 1, end + expandEnd + 4);
+  return { start, end };
+}
+
+function smoothSeries(values: number[], radius: number) {
+  return values.map((_, index) => {
+    let total = 0;
+    let count = 0;
+    for (let offset = -radius; offset <= radius; offset += 1) {
+      const value = values[index + offset];
+      if (value === undefined) {
+        continue;
+      }
+      total += value;
+      count += 1;
+    }
+    return total / Math.max(count, 1);
+  });
+}
+
+function clamp(value: number, min: number, max: number) {
+  return Math.min(Math.max(value, min), max);
+}
+
+async function ensureExactPixelSize(input: Buffer, target: { width: number; height: number }) {
+  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/templates/template_0000/src/remotion/Root.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AbsoluteFill, Composition, Img, Sequence, interpolate, spring, useCurrentFrame, useVideoConfig } from "remotion";
+export const RemotionRoot = () => {
+    return (_jsx(Composition, { id: "template-0000", component: TemplateVideo, width: 1080, height: 1920, fps: 30, durationInFrames: 120, defaultProps: { slides: [] }, calculateMetadata: ({ props }) => ({
+            width: 1080,
+            height: 1920,
+            durationInFrames: Math.max(1, sumSlideFrames(props.slides, 30))
+        }) }));
+};
+const TemplateVideo = ({ slides }) => {
+    const { fps } = useVideoConfig();
+    let currentFrame = 0;
+    return (_jsx(AbsoluteFill, { style: { backgroundColor: "#120f0b" }, children: slides.map((slide, index) => {
+            const durationInFrames = msToFrames(slide.durationMs, fps);
+            const sequence = (_jsx(Sequence, { from: currentFrame, durationInFrames: durationInFrames, children: _jsx(SlideFrame, { slide: slide }) }, `${slide.imageUrl}-${index}`));
+            currentFrame += durationInFrames;
+            return sequence;
+        }) }));
+};
+const SlideFrame = ({ slide }) => {
+    const frame = useCurrentFrame();
+    const { fps } = useVideoConfig();
+    const entrance = spring({ fps, frame, config: { damping: 200, stiffness: 140 } });
+    const opacity = interpolate(entrance, [0, 1], [0.35, 1]);
+    const lift = interpolate(entrance, [0, 1], [22, 0]);
+    return (_jsxs(AbsoluteFill, { children: [_jsx(AbsoluteFill, { style: { opacity, transform: `translateY(${lift}px)` }, children: _jsx(Img, { src: slide.imageUrl, style: { width: "100%", height: "100%", objectFit: "fill" } }) }), _jsx(AbsoluteFill, { style: { background: "linear-gradient(180deg, rgba(0,0,0,0.18) 0%, rgba(0,0,0,0.06) 36%, rgba(0,0,0,0.34) 100%)" } })] }));
+};
+function msToFrames(durationMs, fps) {
+    return Math.max(1, Math.round((durationMs / 1000) * fps));
+}
+function sumSlideFrames(slides, fps) {
+    return slides.reduce((total, slide) => total + msToFrames(slide.durationMs, fps), 0);
+}

package/templates/template_0000/src/remotion/Root.tsx

@@ -0,0 +1,75 @@
+import React from "react";
+import { AbsoluteFill, Composition, Img, Sequence, interpolate, spring, useCurrentFrame, useVideoConfig } from "remotion";
+
+type Slide = {
+  imageUrl: string;
+  durationMs: number;
+};
+
+type TemplateVideoProps = {
+  slides: Slide[];
+};
+
+export const RemotionRoot: React.FC = () => {
+  return (
+    <Composition
+      id="template-0000"
+      component={TemplateVideo}
+      width={1080}
+      height={1920}
+      fps={30}
+      durationInFrames={120}
+      defaultProps={{ slides: [] }}
+      calculateMetadata={({ props }) => ({
+        width: 1080,
+        height: 1920,
+        durationInFrames: Math.max(1, sumSlideFrames(props.slides, 30))
+      })}
+    />
+  );
+};
+
+const TemplateVideo: React.FC<TemplateVideoProps> = ({ slides }) => {
+  const { fps } = useVideoConfig();
+  let currentFrame = 0;
+
+  return (
+    <AbsoluteFill style={{ backgroundColor: "#120f0b" }}>
+      {slides.map((slide, index) => {
+        const durationInFrames = msToFrames(slide.durationMs, fps);
+        const sequence = (
+          <Sequence key={`${slide.imageUrl}-${index}`} from={currentFrame} durationInFrames={durationInFrames}>
+            <SlideFrame slide={slide} />
+          </Sequence>
+        );
+        currentFrame += durationInFrames;
+        return sequence;
+      })}
+    </AbsoluteFill>
+  );
+};
+
+const SlideFrame: React.FC<{ slide: Slide }> = ({ slide }) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+  const entrance = spring({ fps, frame, config: { damping: 200, stiffness: 140 } });
+  const opacity = interpolate(entrance, [0, 1], [0.35, 1]);
+  const lift = interpolate(entrance, [0, 1], [22, 0]);
+
+  return (
+    <AbsoluteFill>
+      <AbsoluteFill style={{ opacity, transform: `translateY(${lift}px)` }}>
+        <Img src={slide.imageUrl} style={{ width: "100%", height: "100%", objectFit: "fill" }} />
+      </AbsoluteFill>
+      <AbsoluteFill style={{ background: "linear-gradient(180deg, rgba(0,0,0,0.18) 0%, rgba(0,0,0,0.06) 36%, rgba(0,0,0,0.34) 100%)" }} />
+    </AbsoluteFill>
+  );
+};
+
+function msToFrames(durationMs: number, fps: number) {
+  return Math.max(1, Math.round((durationMs / 1000) * fps));
+}
+
+function sumSlideFrames(slides: Slide[], fps: number) {
+  return slides.reduce((total, slide) => total + msToFrames(slide.durationMs, fps), 0);
+}

package/templates/template_0000/src/remotion/index.tsx

@@ -0,0 +1,4 @@
+import { registerRoot } from "remotion";
+import { RemotionRoot } from "./Root.js";
+
+registerRoot(RemotionRoot);

package/templates/template_0000/src/sdk.ts

@@ -0,0 +1,122 @@
+import type { ZodTypeAny } from "zod";
+
+export type ProviderType = "openai" | "gemini" | "openrouter" | "perplexity";
+
+export interface TemplateOperationDefinition {
+  description: string;
+  inputSchema: ZodTypeAny;
+  workflow: string;
+  providerHint?: ProviderType;
+  webhookSupport?: boolean;
+  smokeTestPayload?: Record<string, unknown>;
+}
+
+export interface TemplateAboutMetadata {
+  title: string;
+  description: string;
+  viral_dna: string;
+  visual_dna: string;
+  preview_media: string[];
+  link_to_original: string;
+}
+
+export interface JobExecutionResult {
+  progress?: number;
+  output?: Record<string, unknown>;
+}
+
+export interface TemplateDefinition {
+  id: string;
+  slugId: string;
+  version: string;
+  about: TemplateAboutMetadata;
+  configSchema: ZodTypeAny;
+  skillPath?: string;
+  operations: Record<string, TemplateOperationDefinition>;
+  jobs: Record<string, (ctx: TemplateJobContext, input: Record<string, unknown>) => Promise<JobExecutionResult>>;
+}
+
+export interface TemplateJobContext {
+  env: "development" | "production";
+  customer: {
+    id: string;
+    email: string;
+    name: string;
+    defaultWebhookUrl: string | null;
+  };
+  templateConfig: Record<string, unknown>;
+  logger: {
+    debug(message: string, metadata?: Record<string, unknown>): void;
+    info(message: string, metadata?: Record<string, unknown>): void;
+    warn(message: string, metadata?: Record<string, unknown>): void;
+    error(message: string, metadata?: Record<string, unknown>): void;
+    progress(progress: number, message: string, metadata?: Record<string, unknown>): void;
+  };
+  jobs: {
+    enqueueChild(input: {
+      operationName: string;
+      workflowName: string;
+      payload: Record<string, unknown>;
+      providerHint?: ProviderType;
+    }): Promise<{ jobId: string }>;
+  };
+  storage: {
+    putJson(key: string, value: unknown): Promise<{ key: string; url: string | null }>;
+    putText(key: string, value: string, contentType?: string): Promise<{ key: string; url: string | null }>;
+    putBuffer(
+      key: string,
+      value: Uint8Array,
+      options?: { contentType?: string; kind?: string; metadata?: Record<string, unknown> }
+    ): Promise<{ key: string; url: string | null }>;
+    getPublicUrl(key: string): string | null;
+  };
+  billing: {
+    record(input: {
+      type: "ai_generation" | "render" | "storage_write" | "cpu_estimate";
+      costUsd: number;
+      chargeUsd?: number;
+      metadata?: Record<string, unknown>;
+    }): Promise<void>;
+  };
+  providers: {
+    generateText(input: {
+      provider: ProviderType;
+      model: string;
+      prompt: string;
+      temperature?: number;
+    }): Promise<{ text: string; usage: { inputTokens: number; outputTokens: number; costUsd: number } }>;
+    generateImage(input: {
+      provider: ProviderType;
+      model: string;
+      prompt: string;
+      promptAttachments?: string[];
+      size?: string;
+      aspectRatio?: string;
+      imageSize?: "1K" | "2K" | "4K";
+    }): Promise<{ bytes: Uint8Array; contentType: string; revisedPrompt: string | null }>;
+    analyzeImageLayout(input: {
+      provider: ProviderType;
+      model: string;
+      imageUrl: string;
+      overlayText: string;
+    }): Promise<{
+      zone: "top" | "center" | "bottom";
+      align: "left" | "center" | "right";
+      maxWidthPercent: number;
+      justification: string;
+    }>;
+  };
+  remotion: {
+    render(input: {
+      compositionId: string;
+      serveUrl?: string;
+      entryPoint?: string;
+      outputKey?: string;
+      inputProps: Record<string, unknown>;
+    }): Promise<{ renderId: string; outputUrl: string | null; metadata: Record<string, unknown> }>;
+  };
+}
+
+export function defineTemplate(definition: TemplateDefinition): TemplateDefinition {
+  return definition;
+}