@devmotion/cli 0.6.3 → 0.8.0

package/studio/server/chunks/find-stock-image-Cwkwf5gV.js

@@ -0,0 +1,709 @@
+import { z } from 'zod';
+import { f as fieldRegistry, m as meta, h as getLayerDataDefinition, d as defaultLayerStyle, a as defaultTransform } from './animation-sOd5R1cE.js';
+import { nanoid } from 'nanoid';
+import { a as extractDefaultValues } from './base-qepI6vHK.js';
+import { c as calculateContainDimensions, A as ASPECT_RATIOS } from './media-v9Bq2kuR.js';
+
+function createLayer(type, override) {
+  const definition = getLayerDataDefinition(type);
+  const defaultProps = extractDefaultValues(definition.schema);
+  if (type === "video" || type === "image") {
+    if (override?.projectDimensions) {
+      const { width, height } = calculateContainDimensions(
+        override.projectDimensions.width,
+        override.projectDimensions.height,
+        type === "video" ? ASPECT_RATIOS.VIDEO_DEFAULT : ASPECT_RATIOS.IMAGE_DEFAULT
+      );
+      defaultProps.width = width;
+      defaultProps.height = height;
+    }
+  }
+  const initialKeyframes = override?.keyframes ?? [];
+  return {
+    id: nanoid(),
+    name: definition.label,
+    type,
+    transform: {
+      ...defaultTransform(),
+      ...override?.transform
+    },
+    style: {
+      ...defaultLayerStyle(),
+      ...override?.style
+    },
+    visible: true,
+    locked: false,
+    keyframes: initialKeyframes,
+    props: {
+      ...defaultProps,
+      ...override?.props
+    },
+    ...type === "video" || type === "audio" ? { contentOffset: 0 } : {},
+    ...override?.layer
+  };
+}
+function getMediaTiming(sourceLayer, projectDuration) {
+  const enterTime = sourceLayer.enterTime ?? 0;
+  const exitTime = sourceLayer.exitTime ?? projectDuration;
+  const contentOffset = sourceLayer.contentOffset ?? 0;
+  const layerDuration = exitTime - enterTime;
+  return {
+    mediaStartTime: contentOffset,
+    mediaEndTime: contentOffset + layerDuration,
+    audioDuration: layerDuration
+  };
+}
+async function runAction({
+  action,
+  input,
+  sourceLayer,
+  project
+}) {
+  if (action.sourceLayerTypes.length > 0) {
+    if (!sourceLayer) {
+      throw new Error(`Action "${action.id}" requires a source layer`);
+    }
+    if (!action.sourceLayerTypes.includes(sourceLayer.type)) {
+      throw new Error(
+        `Action "${action.id}" requires layer type ${action.sourceLayerTypes.join("/")}, got "${sourceLayer.type}"`
+      );
+    }
+  }
+  const ctx = {
+    sourceLayer,
+    project
+  };
+  const output = await action.execute(input, ctx);
+  return action.apply(input, ctx, output);
+}
+async function runRegisteredAction({
+  action,
+  input,
+  sourceLayer,
+  project
+}) {
+  if (action.sourceLayerTypes.length > 0) {
+    if (!sourceLayer) {
+      throw new Error(`Action "${action.id}" requires a source layer`);
+    }
+    if (!action.sourceLayerTypes.includes(sourceLayer.type)) {
+      throw new Error(
+        `Action "${action.id}" requires layer type ${action.sourceLayerTypes.join("/")}, got "${sourceLayer.type}"`
+      );
+    }
+  }
+  const ctx = {
+    sourceLayer,
+    project
+  };
+  const output = await action.execute(input, ctx);
+  return action.apply(input, ctx, output);
+}
+const GenerateCaptionsSchema = meta.schema.pick({
+  mode: true,
+  blockGap: true,
+  maxWordsPerBlock: true,
+  bgColor: true,
+  fontFamily: true,
+  textColor: true,
+  height: true,
+  width: true,
+  fontSize: true,
+  fontWeight: true,
+  transitionEffects: true,
+  transitionDuration: true,
+  textEffect: true,
+  textEffectColor: true,
+  textEffectSize: true
+}).extend({
+  language: z.string().optional().describe('Language code (e.g. "en", "es"). Omit for auto-detect.'),
+  prompt: z.string().max(5e3).optional().describe("Optional context to guide transcription (lyrics, terminology)"),
+  position: z.enum(["bottom", "top", "middle"]).default("bottom").describe("Caption placement on the canvas.")
+});
+const generateCaptionsAction = {
+  id: "generate-captions",
+  label: "Generate Captions",
+  description: "Transcribe audio/video to synced word-level captions using Whisper AI. Creates a captions layer.",
+  sourceLayerTypes: ["video", "audio"],
+  inputSchema: GenerateCaptionsSchema,
+  async execute(input, ctx) {
+    const { generateCaptions } = await import('./captions.remote-B5ErNQXV.js').then((n) => n.m);
+    const mediaTiming = getMediaTiming(ctx.sourceLayer, ctx.project.duration);
+    const result = await generateCaptions({
+      fileKey: ctx.sourceLayer.props.fileKey,
+      mediaStartTime: mediaTiming.mediaStartTime,
+      mediaEndTime: mediaTiming.mediaEndTime,
+      audioDuration: mediaTiming.audioDuration,
+      prompt: input.prompt,
+      language: input.language
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Caption generation failed");
+    }
+    const data = result.data;
+    if ("needsUpgrade" in data && data.needsUpgrade) {
+      throw new Error(data.error || "Plan upgrade required");
+    }
+    if (!data.success || !data.words) {
+      throw new Error("No words returned from transcription");
+    }
+    return { words: data.words, language: data.language ?? "unknown" };
+  },
+  apply(input, ctx, output) {
+    const margin = 5;
+    const captionsLayer = createLayer("captions", {
+      props: {
+        sourceLayerId: ctx.sourceLayer.id,
+        words: output.words,
+        originalScript: input.prompt ?? "",
+        ...input
+      },
+      layer: {
+        enterTime: ctx.sourceLayer.enterTime,
+        exitTime: ctx.sourceLayer.exitTime,
+        contentOffset: ctx.sourceLayer.contentOffset,
+        contentDuration: ctx.sourceLayer.contentDuration
+      },
+      transform: {
+        position: {
+          y: input.position === "top" ? margin : input.position === "bottom" ? -margin : 0,
+          x: 0,
+          z: 0
+        },
+        anchor: input.position === "top" ? "top-center" : input.position === "bottom" ? "bottom-center" : "center",
+        positionOrigin: input.position === "top" ? "top-center" : input.position === "bottom" ? "bottom-center" : "center"
+      }
+    });
+    return {
+      layersToAdd: [{ layer: captionsLayer }],
+      layersToUpdate: []
+    };
+  },
+  estimateCost(durationSeconds) {
+    return durationSeconds / 60 * 6e-3;
+  }
+};
+const dubLanguages = [
+  { value: "en", label: "English" },
+  { value: "es", label: "Spanish" },
+  { value: "fr", label: "French" },
+  { value: "de", label: "German" },
+  { value: "it", label: "Italian" },
+  { value: "pt", label: "Portuguese" },
+  { value: "ru", label: "Russian" },
+  { value: "ja", label: "Japanese" },
+  { value: "ko", label: "Korean" },
+  { value: "zh", label: "Chinese" },
+  { value: "ar", label: "Arabic" },
+  { value: "hi", label: "Hindi" },
+  { value: "nl", label: "Dutch" },
+  { value: "pl", label: "Polish" },
+  { value: "tr", label: "Turkish" }
+];
+const dubLanguageCodes = dubLanguages.map((l) => l.value);
+const DubAudioSchema = z.object({
+  targetLang: z.enum(dubLanguageCodes).describe('Target language code for dubbing (e.g. "es", "fr")'),
+  sourceLang: z.string().optional().describe("Source language code. Omit for auto-detect.")
+});
+const dubAudioAction = {
+  id: "dub-audio",
+  label: "Dub Audio",
+  description: "Dub audio to another language via ElevenLabs AI voice cloning. Creates a dubbed audio layer and mutes the original.",
+  sourceLayerTypes: ["audio", "video"],
+  requiresApproval: true,
+  inputSchema: DubAudioSchema,
+  async execute(input, ctx) {
+    const { dubAudio } = await import('./dubbing.remote-tYalz3IA.js').then((n) => n.m);
+    if (!ctx.sourceLayer.contentDuration) {
+      throw new Error("Source layer must have a content duration");
+    }
+    const result = await dubAudio({
+      fileKey: ctx.sourceLayer.props.fileKey,
+      targetLang: input.targetLang,
+      sourceLang: input.sourceLang,
+      audioDuration: ctx.sourceLayer.contentDuration
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Dubbing failed");
+    }
+    const data = result.data;
+    if ("needsUpgrade" in data && data.needsUpgrade) {
+      throw new Error(data.error || "Plan upgrade required");
+    }
+    if (!data.success || !("url" in data)) {
+      throw new Error("Dubbing returned no audio URL");
+    }
+    return { url: data.url, key: data.key, language: data.language };
+  },
+  apply(_input, ctx, output) {
+    const langUpper = output.language.toUpperCase();
+    const sourceName = ctx.sourceLayer.name || "Audio";
+    const dubbedLayer = createLayer("audio", {
+      props: {
+        src: output.url,
+        fileKey: output.key
+      },
+      layer: {
+        enterTime: ctx.sourceLayer.enterTime,
+        exitTime: ctx.sourceLayer.exitTime,
+        contentOffset: ctx.sourceLayer.contentOffset,
+        contentDuration: ctx.sourceLayer.contentDuration,
+        name: `${sourceName} (${langUpper})`
+      }
+    });
+    return {
+      layersToAdd: [{ layer: dubbedLayer }],
+      layersToUpdate: [
+        {
+          id: ctx.sourceLayer.id,
+          changes: { props: { ...ctx.sourceLayer.props, muted: true } }
+        }
+      ]
+    };
+  },
+  estimateCost(durationSeconds) {
+    return durationSeconds / 60 * 0.5;
+  }
+};
+const ExtractAudioSchema = z.object({});
+const extractAudioAction = {
+  id: "extract-audio",
+  label: "Extract Audio",
+  description: "Extract audio track from a video layer via FFmpeg. Creates an audio layer, mutes the original video.",
+  sourceLayerTypes: ["video"],
+  inputSchema: ExtractAudioSchema,
+  async execute(_input, ctx) {
+    const { extractAudio } = await import('./extract-audio.remote-BKBT80-g.js').then((n) => n.m);
+    if (!ctx.sourceLayer.contentDuration) {
+      throw new Error("Source layer must have a content duration");
+    }
+    const result = await extractAudio({
+      fileKey: ctx.sourceLayer.props.fileKey,
+      mediaStartTime: ctx.sourceLayer.contentOffset ?? 0,
+      mediaEndTime: (ctx.sourceLayer.exitTime ?? ctx.project.duration) - (ctx.sourceLayer.enterTime ?? 0)
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Audio extraction failed");
+    }
+    const data = result.data;
+    if (!data.success) {
+      throw new Error("Audio extraction returned no file");
+    }
+    return { url: data.url, key: data.key };
+  },
+  apply(input, ctx, output) {
+    const sourceName = ctx.sourceLayer.name || "Video";
+    const enterTime = ctx.sourceLayer.enterTime ?? 0;
+    const exitTime = ctx.sourceLayer.exitTime ?? ctx.project.duration;
+    const layerDuration = exitTime - enterTime;
+    const audioLayer = createLayer("audio", {
+      props: {
+        src: output.url,
+        fileKey: output.key
+      },
+      layer: {
+        enterTime: ctx.sourceLayer.enterTime,
+        exitTime: ctx.sourceLayer.exitTime,
+        contentOffset: 0,
+        contentDuration: layerDuration,
+        name: `${sourceName} Audio`
+      }
+    });
+    return {
+      layersToAdd: [{ layer: audioLayer }],
+      layersToUpdate: [
+        {
+          id: ctx.sourceLayer.id,
+          changes: { props: { ...ctx.sourceLayer.props, muted: true } }
+        }
+      ]
+    };
+  }
+};
+const round1 = (v) => Math.round(v * 10) / 10;
+const toPct = (fraction) => round1(fraction * 100);
+const pxToPct = (d, px) => round1(px / d.width * 100);
+function size(d, wPct, hPct) {
+  const ar = d.height / d.width;
+  return {
+    width: toPct(wPct),
+    height: toPct((hPct ?? wPct) * ar)
+  };
+}
+function splitLeft(d, ratio = 0.5) {
+  const ar = d.height / d.width;
+  return {
+    x: toPct(-0.5 + ratio / 2),
+    y: 0,
+    width: toPct(ratio),
+    height: toPct(ar)
+  };
+}
+function splitRight(d, ratio = 0.5) {
+  const ar = d.height / d.width;
+  return {
+    x: toPct(0.5 - ratio / 2),
+    y: 0,
+    width: toPct(ratio),
+    height: toPct(ar)
+  };
+}
+function deviceSize(d, type) {
+  const ar = d.height / d.width;
+  const minFrac = Math.min(1, ar);
+  switch (type) {
+    case "laptop":
+      return { width: 100, height: toPct(800 / 1280) };
+    // 100, 62.5
+    case "phone":
+      return { width: toPct(minFrac * 0.3), height: toPct(minFrac * 0.6) };
+    case "browser":
+      return { width: toPct(minFrac * 0.85), height: toPct(minFrac * 0.55) };
+  }
+}
+function videoSize(d, opts) {
+  const ratio = opts?.ratio ?? 16 / 9;
+  const scaleFactor = opts?.scale ?? 0.65;
+  const ar = d.height / d.width;
+  let wFrac = scaleFactor;
+  let hFrac = scaleFactor / ratio;
+  const maxHFrac = scaleFactor * ar;
+  if (hFrac > maxHFrac) {
+    hFrac = maxHFrac;
+    wFrac = hFrac * ratio;
+  }
+  return { width: toPct(wFrac), height: toPct(hFrac) };
+}
+function inferSeedanceRatio(width, height) {
+  const ar = width / height;
+  const candidates = [
+    [16 / 9, "16:9"],
+    [4 / 3, "4:3"],
+    [1, "1:1"],
+    [3 / 4, "3:4"],
+    [9 / 16, "9:16"],
+    [21 / 9, "21:9"]
+  ];
+  let closest = candidates[0];
+  for (const c of candidates) {
+    if (Math.abs(c[0] - ar) < Math.abs(closest[0] - ar)) closest = c;
+  }
+  return closest[1];
+}
+const GenerateVideoSchema = z.object({
+  prompt: z.string().min(10, "Please describe your video in at least 10 characters").max(2e3).describe(
+    "Describe the video you want to generate. Be specific about subjects, motion, lighting, and mood."
+  ).register(fieldRegistry, {
+    label: "Video description",
+    widget: "textarea"
+  }),
+  duration: z.number().int().min(4).max(15).default(5).describe("Between 4 and 15 seconds.").register(fieldRegistry, {
+    label: "Duration (seconds)"
+  }),
+  resolution: z.enum(["480p", "720p"]).default("480p").register(fieldRegistry, {
+    label: "Resolution",
+    widget: "select",
+    options: [
+      { value: "720p", label: "720p (HD)" },
+      { value: "480p", label: "480p (faster, cheaper)" }
+    ]
+  }),
+  generateAudio: z.boolean().default(true).describe("Add synchronized ambient audio to the generated video.").register(fieldRegistry, {
+    label: "Generate AI audio"
+  })
+});
+const generateVideoAction = {
+  id: "generate-video",
+  label: "Generate Video",
+  description: "Generate a video from a text prompt using Seedance 2.0 AI. Creates a video layer.",
+  sourceLayerTypes: [],
+  requiresApproval: true,
+  inputSchema: GenerateVideoSchema,
+  async execute(input, ctx) {
+    const { generateVideo } = await import('./video-generation.remote-CBblzjAk.js').then((n) => n.m);
+    const { width, height } = ctx.project;
+    const ratio = inferSeedanceRatio(width, height);
+    const result = await generateVideo({
+      prompt: input.prompt,
+      duration: input.duration,
+      resolution: input.resolution,
+      ratio,
+      generateAudio: input.generateAudio
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Video generation failed");
+    }
+    const data = result.data;
+    if ("needsUpgrade" in data && data.needsUpgrade) {
+      throw new Error(data.error || "Plan upgrade required");
+    }
+    if (!data.success || !("url" in data)) {
+      throw new Error("Video generation returned no URL");
+    }
+    return {
+      url: data.url,
+      key: data.key
+    };
+  },
+  apply(input, ctx, output) {
+    const { width, height, duration: projectDuration } = ctx.project;
+    const enterTime = 0;
+    const exitTime = input.duration;
+    const videoLayer = createLayer("video", {
+      props: {
+        src: output.url,
+        fileKey: output.key,
+        width: 100,
+        height: toPct(height / width),
+        objectFit: "cover",
+        borderRadius: 0,
+        frame: "none",
+        frameWidth: 0
+      },
+      projectDimensions: { width, height },
+      layer: {
+        name: "AI Generated Video",
+        enterTime,
+        exitTime,
+        contentDuration: input.duration
+      }
+    });
+    return {
+      layersToAdd: [{ layer: videoLayer }],
+      projectUpdates: { ...exitTime > projectDuration ? { duration: exitTime } : {} }
+    };
+  }
+};
+const GenerateSpeechSchema = z.object({
+  text: z.string().trim().min(1, "Text is required").max(5e3, "Text is too long").describe("The script to synthesize into speech."),
+  voiceId: z.string().min(1).describe("ElevenLabs voice ID to use for synthesis."),
+  modelId: z.enum([
+    "eleven_v3",
+    "eleven_v3_turbo",
+    "eleven_multilingual_v2",
+    "eleven_turbo_v2_5",
+    "eleven_flash_v2_5"
+  ]).optional().describe("ElevenLabs TTS model ID. Defaults to eleven_v3."),
+  stability: z.number().min(0).max(1).optional(),
+  similarityBoost: z.number().min(0).max(1).optional()
+});
+const generateSpeechAction = {
+  id: "generate-speech",
+  label: "Generate Speech",
+  description: "Synthesize text into speech via ElevenLabs TTS. Replaces the source audio layer content.",
+  sourceLayerTypes: ["audio"],
+  requiresApproval: true,
+  inputSchema: GenerateSpeechSchema,
+  async execute(input, _ctx) {
+    const { generateSpeech } = await import('./tts.remote-Btrg7DBL.js').then((n) => n.m);
+    const result = await generateSpeech({
+      text: input.text,
+      voiceId: input.voiceId,
+      modelId: input.modelId,
+      stability: input.stability,
+      similarityBoost: input.similarityBoost
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Speech generation failed");
+    }
+    const data = result.data;
+    if ("needsUpgrade" in data && data.needsUpgrade) {
+      throw new Error(data.error || "Plan upgrade required");
+    }
+    if (!data.success || !("url" in data)) {
+      throw new Error("TTS returned no audio URL");
+    }
+    return {
+      url: data.url,
+      key: data.key,
+      charCount: data.charCount,
+      duration: data.duration ?? null
+    };
+  },
+  apply(input, ctx, output) {
+    const enterTime = ctx.sourceLayer.enterTime ?? 0;
+    const hasDuration = typeof output.duration === "number" && Number.isFinite(output.duration);
+    return {
+      layersToAdd: [],
+      layersToUpdate: [
+        {
+          id: ctx.sourceLayer.id,
+          changes: {
+            ...hasDuration ? {
+              exitTime: enterTime + output.duration,
+              contentDuration: output.duration,
+              contentOffset: 0
+            } : {},
+            props: {
+              ...ctx.sourceLayer.props,
+              src: output.url,
+              fileKey: output.key,
+              generatedFromText: input.text
+            }
+          }
+        }
+      ]
+    };
+  },
+  // Cost is billed per-character, not per-second, so we expose a conservative
+  // non-zero estimate only for the generic "duration-based" contract.
+  estimateCost(_durationSeconds) {
+    return 0;
+  }
+};
+const GenerateImageSchema = z.object({
+  prompt: z.string().min(3, "Please describe your image").max(4e3).describe(
+    "Describe the image to generate. Be specific about subject, style, lighting, composition, and mood."
+  ).register(fieldRegistry, {
+    label: "Image description",
+    widget: "textarea"
+  }),
+  aspect: z.enum(["square", "landscape", "portrait"]).default("square").describe("Aspect ratio: square (1:1), landscape (3:2), portrait (2:3).").register(fieldRegistry, {
+    label: "Aspect ratio",
+    widget: "select",
+    options: [
+      { value: "square", label: "Square (1:1)" },
+      { value: "landscape", label: "Landscape (3:2)" },
+      { value: "portrait", label: "Portrait (2:3)" }
+    ]
+  }),
+  transparentBackground: z.boolean().default(false).describe("Generate with a transparent background (PNG) — ideal for logos, icons, cutouts.").register(fieldRegistry, {
+    label: "Transparent background"
+  })
+});
+const generateImageAction = {
+  id: "generate-image",
+  label: "Generate Image",
+  description: "Generate an image from a text prompt using AI. The result is saved to the asset library and added as an image layer.",
+  sourceLayerTypes: [],
+  requiresApproval: true,
+  inputSchema: GenerateImageSchema,
+  async execute(input) {
+    const { generateImage } = await import('./image-generation.remote-omBcspXi.js').then((n) => n.m);
+    const result = await generateImage({
+      prompt: input.prompt,
+      aspect: input.aspect,
+      transparentBackground: input.transparentBackground
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Image generation failed");
+    }
+    const data = result.data;
+    if ("needsUpgrade" in data && data.needsUpgrade) {
+      throw new Error(data.error || "Plan upgrade required");
+    }
+    if (!data.success || !("url" in data)) {
+      throw new Error("Image generation returned no URL");
+    }
+    return {
+      url: data.url,
+      key: data.key,
+      width: data.width,
+      height: data.height
+    };
+  },
+  apply(input, ctx, output) {
+    const { width: projectWidth, height: projectHeight } = ctx.project;
+    const layerWidth = 60;
+    const layerHeight = layerWidth * (output.height / output.width);
+    const imageLayer = createLayer("image", {
+      props: {
+        src: output.url,
+        fileKey: output.key,
+        fileName: `ai-image.png`,
+        width: layerWidth,
+        height: layerHeight,
+        objectFit: "contain"
+      },
+      projectDimensions: { width: projectWidth, height: projectHeight },
+      layer: {
+        name: "AI Generated Image"
+      }
+    });
+    return {
+      layersToAdd: [{ layer: imageLayer }]
+    };
+  }
+};
+const FindStockImageSchema = z.object({
+  query: z.string().min(2, "Describe what to search for").max(200).describe(
+    'Stock photo search query — subject, mood, setting (e.g. "team meeting modern office", "mountain sunrise mist").'
+  ).register(fieldRegistry, {
+    label: "Search query"
+  }),
+  orientation: z.enum(["square", "horizontal", "vertical"]).optional().describe("Preferred orientation. Match the project canvas when possible.").register(fieldRegistry, {
+    label: "Orientation",
+    widget: "select",
+    options: [
+      { value: "horizontal", label: "Horizontal" },
+      { value: "vertical", label: "Vertical" },
+      { value: "square", label: "Square" }
+    ]
+  }),
+  imageType: z.enum(["photo", "illustration", "3d"]).optional().describe("Kind of imagery: photo (default), illustration, or 3d render.").register(fieldRegistry, {
+    label: "Image type",
+    widget: "select",
+    options: [
+      { value: "photo", label: "Photo" },
+      { value: "illustration", label: "Illustration" },
+      { value: "3d", label: "3D render" }
+    ]
+  })
+});
+const findStockImageAction = {
+  id: "find-stock-image",
+  label: "Find Stock Image",
+  description: "Search real stock photography/illustrations (Lummi), import the best match to the asset library, and add it as an image layer with attribution.",
+  sourceLayerTypes: [],
+  inputSchema: FindStockImageSchema,
+  async execute(input) {
+    const { findStockImage } = await import('./stock-image.remote-Cn_Dh7Ok.js').then((n) => n.m);
+    const result = await findStockImage({
+      query: input.query,
+      orientation: input.orientation,
+      imageType: input.imageType
+    });
+    if (!result.success) {
+      throw new Error(result.error || "Stock image search failed");
+    }
+    const data = result.data;
+    if (!data.success) {
+      throw new Error(data.error || "No stock image found");
+    }
+    return {
+      url: data.url,
+      key: data.key,
+      fileName: data.fileName,
+      width: data.width,
+      height: data.height,
+      description: data.description,
+      attribution: data.attribution
+    };
+  },
+  apply(input, ctx, output) {
+    const { width: projectWidth, height: projectHeight } = ctx.project;
+    const layerWidth = 60;
+    const layerHeight = layerWidth * (output.height / output.width);
+    const imageLayer = createLayer("image", {
+      props: {
+        src: output.url,
+        fileKey: output.key,
+        fileName: output.fileName,
+        width: layerWidth,
+        height: layerHeight,
+        objectFit: "cover",
+        attribution: output.attribution
+      },
+      projectDimensions: { width: projectWidth, height: projectHeight },
+      layer: {
+        name: `Stock: ${input.query.slice(0, 30)}`
+      }
+    });
+    return {
+      layersToAdd: [{ layer: imageLayer }]
+    };
+  }
+};
+
+export { GenerateVideoSchema as G, generateImageAction as a, generateVideoAction as b, generateCaptionsAction as c, dubAudioAction as d, extractAudioAction as e, findStockImageAction as f, generateSpeechAction as g, createLayer as h, splitRight as i, deviceSize as j, round1 as k, size as l, runAction as m, dubLanguages as n, pxToPct as p, runRegisteredAction as r, splitLeft as s, toPct as t, videoSize as v };
+//# sourceMappingURL=find-stock-image-Cwkwf5gV.js.map