@depths/waves 0.1.0

package/dist/cli.js

@@ -0,0 +1,1107 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(cli_exports);
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/version.ts
+var __wavesVersion = "0.1.0";
+
+// src/utils/json-schema.ts
+var import_zod = require("zod");
+function zodSchemaToJsonSchema(schema) {
+  return import_zod.z.toJSONSchema(schema);
+}
+
+// src/ir/schema.ts
+var import_zod2 = require("zod");
+var TimingSpecSchema = import_zod2.z.object({
+  from: import_zod2.z.number().int().min(0).describe("Start frame (0-indexed)"),
+  durationInFrames: import_zod2.z.number().int().positive().describe("Duration in frames")
+});
+var AssetPathSchema = import_zod2.z.string().refine(
+  (path3) => path3.startsWith("/") || path3.startsWith("http://") || path3.startsWith("https://"),
+  "Asset path must be absolute (starting with /) or a full URL"
+).describe("Path to asset file, either absolute path or URL");
+var BackgroundSpecSchema = import_zod2.z.discriminatedUnion("type", [
+  import_zod2.z.object({
+    type: import_zod2.z.literal("color"),
+    value: import_zod2.z.string().regex(/^#[0-9A-Fa-f]{6}$/, "Must be valid hex color")
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("image"),
+    value: AssetPathSchema
+  }),
+  import_zod2.z.object({
+    type: import_zod2.z.literal("video"),
+    value: AssetPathSchema
+  })
+]);
+var BaseComponentIRSchema = import_zod2.z.object({
+  id: import_zod2.z.string().min(1).max(100).describe("Unique component instance ID"),
+  type: import_zod2.z.string().min(1).describe("Component type identifier"),
+  timing: TimingSpecSchema,
+  metadata: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional().describe("Optional metadata")
+});
+var TextComponentIRSchema = BaseComponentIRSchema.extend({
+  type: import_zod2.z.literal("Text"),
+  props: import_zod2.z.object({
+    content: import_zod2.z.string().min(1).max(1e3),
+    fontSize: import_zod2.z.number().int().min(12).max(200).default(48),
+    color: import_zod2.z.string().regex(/^#[0-9A-Fa-f]{6}$/).default("#FFFFFF"),
+    position: import_zod2.z.enum(["top", "center", "bottom", "left", "right"]).default("center"),
+    animation: import_zod2.z.enum(["none", "fade", "slide", "zoom"]).default("fade")
+  })
+});
+var AudioComponentIRSchema = BaseComponentIRSchema.extend({
+  type: import_zod2.z.literal("Audio"),
+  props: import_zod2.z.object({
+    src: AssetPathSchema,
+    volume: import_zod2.z.number().min(0).max(1).default(1),
+    startFrom: import_zod2.z.number().int().min(0).default(0).describe("Start playback from frame N"),
+    fadeIn: import_zod2.z.number().int().min(0).default(0).describe("Fade in duration in frames"),
+    fadeOut: import_zod2.z.number().int().min(0).default(0).describe("Fade out duration in frames")
+  })
+});
+function getComponentIRSchema() {
+  return ComponentIRSchema;
+}
+var SceneComponentIRSchema = BaseComponentIRSchema.extend({
+  type: import_zod2.z.literal("Scene"),
+  props: import_zod2.z.object({
+    background: BackgroundSpecSchema
+  }),
+  children: import_zod2.z.lazy(() => import_zod2.z.array(getComponentIRSchema())).optional()
+});
+var ComponentIRSchema = import_zod2.z.discriminatedUnion("type", [
+  SceneComponentIRSchema,
+  TextComponentIRSchema,
+  AudioComponentIRSchema
+]);
+var VideoIRSchema = import_zod2.z.object({
+  version: import_zod2.z.literal("1.0").describe("IR schema version"),
+  video: import_zod2.z.object({
+    id: import_zod2.z.string().default("main"),
+    width: import_zod2.z.number().int().min(360).max(7680),
+    height: import_zod2.z.number().int().min(360).max(4320),
+    fps: import_zod2.z.number().int().min(1).max(120).default(30),
+    durationInFrames: import_zod2.z.number().int().positive()
+  }),
+  audio: import_zod2.z.object({
+    background: AssetPathSchema.optional(),
+    volume: import_zod2.z.number().min(0).max(1).default(0.5)
+  }).optional(),
+  scenes: import_zod2.z.array(SceneComponentIRSchema).min(1)
+});
+
+// src/core/registry.ts
+var ComponentRegistry = class {
+  components = /* @__PURE__ */ new Map();
+  register(registration) {
+    if (this.components.has(registration.type)) {
+      throw new Error(`Component type "${registration.type}" is already registered`);
+    }
+    this.components.set(registration.type, registration);
+  }
+  get(type) {
+    return this.components.get(type);
+  }
+  getTypes() {
+    return Array.from(this.components.keys());
+  }
+  has(type) {
+    return this.components.has(type);
+  }
+  getJSONSchemaForLLM() {
+    const schemas = {};
+    for (const [type, registration] of this.components) {
+      schemas[type] = {
+        schema: zodSchemaToJsonSchema(registration.propsSchema),
+        metadata: registration.metadata
+      };
+    }
+    return schemas;
+  }
+  validateProps(type, props) {
+    const registration = this.components.get(type);
+    if (!registration) {
+      throw new Error(`Unknown component type: ${type}`);
+    }
+    const result = registration.propsSchema.safeParse(props);
+    if (result.success) {
+      return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+  }
+};
+var globalRegistry = new ComponentRegistry();
+
+// src/components/primitives/Audio.tsx
+var import_remotion = require("remotion");
+var import_zod3 = require("zod");
+
+// src/utils/assets.ts
+function isRemoteAssetPath(assetPath) {
+  return assetPath.startsWith("http://") || assetPath.startsWith("https://");
+}
+function staticFileInputFromAssetPath(assetPath) {
+  if (isRemoteAssetPath(assetPath)) {
+    throw new Error("Remote asset paths must not be passed to staticFile()");
+  }
+  return assetPath.startsWith("/") ? assetPath.slice(1) : assetPath;
+}
+
+// src/components/primitives/Audio.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var AudioPropsSchema = import_zod3.z.object({
+  src: import_zod3.z.string(),
+  volume: import_zod3.z.number().min(0).max(1).default(1),
+  startFrom: import_zod3.z.number().int().min(0).default(0),
+  fadeIn: import_zod3.z.number().int().min(0).default(0),
+  fadeOut: import_zod3.z.number().int().min(0).default(0)
+});
+var Audio = ({
+  src,
+  volume,
+  startFrom,
+  fadeIn,
+  fadeOut,
+  __wavesDurationInFrames
+}) => {
+  const frame = (0, import_remotion.useCurrentFrame)();
+  const durationInFrames = __wavesDurationInFrames ?? Number.POSITIVE_INFINITY;
+  const fadeInFactor = fadeIn > 0 ? (0, import_remotion.interpolate)(frame, [0, fadeIn], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  }) : 1;
+  const fadeOutStart = durationInFrames - fadeOut;
+  const fadeOutFactor = fadeOut > 0 ? (0, import_remotion.interpolate)(frame, [fadeOutStart, durationInFrames], [1, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  }) : 1;
+  const resolvedSrc = isRemoteAssetPath(src) ? src : (0, import_remotion.staticFile)(staticFileInputFromAssetPath(src));
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_remotion.Audio,
+    {
+      src: resolvedSrc,
+      trimBefore: startFrom,
+      volume: volume * fadeInFactor * fadeOutFactor
+    }
+  );
+};
+var AudioComponentMetadata = {
+  category: "primitive",
+  description: "Plays an audio file with optional trimming and fade in/out",
+  llmGuidance: "Use for background music or sound effects. Prefer short clips for SFX. Use fadeIn/fadeOut (in frames) for smoother audio starts/ends."
+};
+
+// src/components/primitives/Scene.tsx
+var import_remotion2 = require("remotion");
+var import_zod4 = require("zod");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var ScenePropsSchema = import_zod4.z.object({
+  background: BackgroundSpecSchema
+});
+var resolveAsset = (value) => {
+  return isRemoteAssetPath(value) ? value : (0, import_remotion2.staticFile)(staticFileInputFromAssetPath(value));
+};
+var Scene = ({ background, children }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_remotion2.AbsoluteFill, { children: [
+    background.type === "color" ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_remotion2.AbsoluteFill, { style: { backgroundColor: background.value } }) : background.type === "image" ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_remotion2.Img,
+      {
+        src: resolveAsset(background.value),
+        style: { width: "100%", height: "100%", objectFit: "cover" }
+      }
+    ) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      import_remotion2.Video,
+      {
+        src: resolveAsset(background.value),
+        style: { width: "100%", height: "100%", objectFit: "cover" }
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_remotion2.AbsoluteFill, { children })
+  ] });
+};
+var SceneComponentMetadata = {
+  category: "primitive",
+  description: "Scene container with a background and nested children",
+  llmGuidance: "Use Scene to define a segment of the video. Scene timings must be sequential with no gaps. Put Text and Audio as children."
+};
+
+// src/components/primitives/Text.tsx
+var import_remotion3 = require("remotion");
+var import_zod5 = require("zod");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var TextPropsSchema = import_zod5.z.object({
+  content: import_zod5.z.string(),
+  fontSize: import_zod5.z.number().default(48),
+  color: import_zod5.z.string().default("#FFFFFF"),
+  position: import_zod5.z.enum(["top", "center", "bottom", "left", "right"]).default("center"),
+  animation: import_zod5.z.enum(["none", "fade", "slide", "zoom"]).default("fade")
+});
+var getPositionStyles = (position) => {
+  const base = {
+    display: "flex",
+    justifyContent: "center",
+    alignItems: "center"
+  };
+  switch (position) {
+    case "top":
+      return { ...base, alignItems: "flex-start", paddingTop: 60 };
+    case "bottom":
+      return { ...base, alignItems: "flex-end", paddingBottom: 60 };
+    case "left":
+      return { ...base, justifyContent: "flex-start", paddingLeft: 60 };
+    case "right":
+      return { ...base, justifyContent: "flex-end", paddingRight: 60 };
+    default:
+      return base;
+  }
+};
+var getAnimationStyle = (frame, animation) => {
+  const animDuration = 30;
+  switch (animation) {
+    case "fade": {
+      const opacity = (0, import_remotion3.interpolate)(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { opacity };
+    }
+    case "slide": {
+      const translateY = (0, import_remotion3.interpolate)(frame, [0, animDuration], [50, 0], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      const opacity = (0, import_remotion3.interpolate)(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { transform: `translateY(${translateY}px)`, opacity };
+    }
+    case "zoom": {
+      const scale = (0, import_remotion3.interpolate)(frame, [0, animDuration], [0.8, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      const opacity = (0, import_remotion3.interpolate)(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { transform: `scale(${scale})`, opacity };
+    }
+    default:
+      return {};
+  }
+};
+var Text = ({ content, fontSize, color, position, animation }) => {
+  const frame = (0, import_remotion3.useCurrentFrame)();
+  const positionStyles = getPositionStyles(position);
+  const animationStyles = getAnimationStyle(frame, animation);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_remotion3.AbsoluteFill, { style: positionStyles, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "div",
+    {
+      style: {
+        fontSize,
+        color,
+        fontWeight: 600,
+        textAlign: "center",
+        ...animationStyles
+      },
+      children: content
+    }
+  ) });
+};
+var TextComponentMetadata = {
+  category: "primitive",
+  description: "Displays animated text with positioning and animation options",
+  llmGuidance: 'Use for titles, subtitles, captions. Keep content under 100 characters for readability. Position "center" works best for titles.',
+  examples: [
+    {
+      content: "Welcome to Waves",
+      fontSize: 72,
+      color: "#FFFFFF",
+      position: "center",
+      animation: "fade"
+    },
+    {
+      content: "Building the future of video",
+      fontSize: 36,
+      color: "#CCCCCC",
+      position: "bottom",
+      animation: "slide"
+    }
+  ]
+};
+
+// src/components/registry.ts
+function registerBuiltInComponents() {
+  if (!globalRegistry.has("Scene")) {
+    globalRegistry.register({
+      type: "Scene",
+      component: Scene,
+      propsSchema: ScenePropsSchema,
+      metadata: SceneComponentMetadata
+    });
+  }
+  if (!globalRegistry.has("Text")) {
+    globalRegistry.register({
+      type: "Text",
+      component: Text,
+      propsSchema: TextPropsSchema,
+      metadata: TextComponentMetadata
+    });
+  }
+  if (!globalRegistry.has("Audio")) {
+    globalRegistry.register({
+      type: "Audio",
+      component: Audio,
+      propsSchema: AudioPropsSchema,
+      metadata: AudioComponentMetadata
+    });
+  }
+}
+
+// src/llm/prompt.ts
+var RULES = {
+  timing: [
+    "All timing is in frames (integers).",
+    "Every component has timing: { from, durationInFrames }.",
+    "Scenes must be sequential: scene[0].timing.from = 0 and each next scene starts where the previous ends (no gaps/overlaps).",
+    "Sum of all scene durations must equal video.durationInFrames.",
+    "Child components inside a Scene must fit within the Scene duration."
+  ],
+  assets: [
+    'Asset paths must be either full URLs (http:// or https://) or absolute public paths starting with "/".',
+    'When using absolute public paths ("/assets/..."), the renderer resolves them relative to the --publicDir passed at render time.'
+  ],
+  ids: [
+    "Every component must have a stable string id.",
+    "Ids should be unique within the whole IR."
+  ],
+  output: [
+    "Return only a single JSON object (no markdown fences, no commentary).",
+    "The JSON must validate against the provided JSON Schemas.",
+    'Only use component "type" values that exist in schemas.components.'
+  ]
+};
+function getSystemPrompt(registeredTypes) {
+  const typesLine = registeredTypes.length ? registeredTypes.join(", ") : "(none)";
+  return [
+    "You generate JSON for @depths/waves Video IR (version 1.0).",
+    "",
+    "Goal:",
+    "- Produce a single JSON object that conforms to the provided Video IR JSON Schema and uses only registered component types.",
+    "",
+    "Registered component types:",
+    `- ${typesLine}`,
+    "",
+    "Authoring rules:",
+    ...RULES.output.map((r) => `- ${r}`),
+    ...RULES.timing.map((r) => `- ${r}`),
+    ...RULES.assets.map((r) => `- ${r}`),
+    ...RULES.ids.map((r) => `- ${r}`),
+    "",
+    "If you are unsure about an asset, prefer a solid color Scene background and omit optional props to use defaults.",
+    ""
+  ].join("\n");
+}
+function getPromptPayload(options) {
+  registerBuiltInComponents();
+  const registry = options?.registry ?? globalRegistry;
+  const types = registry.getTypes().sort();
+  return {
+    package: "@depths/waves",
+    version: __wavesVersion,
+    irVersion: "1.0",
+    systemPrompt: getSystemPrompt(types),
+    schemas: {
+      videoIR: zodSchemaToJsonSchema(VideoIRSchema),
+      components: registry.getJSONSchemaForLLM()
+    },
+    rules: {
+      timing: [...RULES.timing],
+      assets: [...RULES.assets],
+      ids: [...RULES.ids],
+      output: [...RULES.output]
+    }
+  };
+}
+
+// src/core/validator.ts
+var IRValidator = class {
+  validateSchema(ir) {
+    const result = VideoIRSchema.safeParse(ir);
+    if (!result.success) {
+      return {
+        success: false,
+        errors: result.error.issues.map((issue) => ({
+          path: issue.path.map((p) => String(p)),
+          message: issue.message,
+          code: issue.code
+        }))
+      };
+    }
+    return { success: true, data: result.data };
+  }
+  validateSemantics(ir) {
+    const errors = [];
+    const totalSceneDuration = ir.scenes.reduce((sum, scene) => sum + scene.timing.durationInFrames, 0);
+    if (totalSceneDuration !== ir.video.durationInFrames) {
+      errors.push({
+        path: ["scenes"],
+        message: `Sum of scene durations (${totalSceneDuration}) does not match video duration (${ir.video.durationInFrames})`,
+        code: "DURATION_MISMATCH"
+      });
+    }
+    let expectedFrame = 0;
+    for (const [i, scene] of ir.scenes.entries()) {
+      if (scene.timing.from !== expectedFrame) {
+        errors.push({
+          path: ["scenes", String(i), "timing", "from"],
+          message: `Scene ${i} starts at frame ${scene.timing.from}, expected ${expectedFrame}`,
+          code: "TIMING_GAP_OR_OVERLAP"
+        });
+      }
+      expectedFrame += scene.timing.durationInFrames;
+    }
+    for (const [i, scene] of ir.scenes.entries()) {
+      if (scene.children && scene.children.length > 0) {
+        this.validateComponentTimingRecursive(
+          scene.children,
+          scene.timing.durationInFrames,
+          ["scenes", String(i)],
+          errors
+        );
+      }
+    }
+    if (errors.length > 0) {
+      return { success: false, errors };
+    }
+    return { success: true };
+  }
+  validate(ir) {
+    const schemaResult = this.validateSchema(ir);
+    if (!schemaResult.success) {
+      return schemaResult;
+    }
+    const semanticsResult = this.validateSemantics(schemaResult.data);
+    if (!semanticsResult.success) {
+      return { success: false, errors: semanticsResult.errors ?? [] };
+    }
+    return schemaResult;
+  }
+  validateComponentTimingRecursive(components, parentDuration, pathPrefix, errors) {
+    for (const [i, component] of components.entries()) {
+      const componentEnd = component.timing.from + component.timing.durationInFrames;
+      if (componentEnd > parentDuration) {
+        errors.push({
+          path: [...pathPrefix, "children", String(i), "timing"],
+          message: `Component extends beyond parent duration (${componentEnd} > ${parentDuration})`,
+          code: "COMPONENT_EXCEEDS_PARENT"
+        });
+      }
+      if (component.type === "Scene" && component.children && component.children.length > 0) {
+        this.validateComponentTimingRecursive(
+          component.children,
+          component.timing.durationInFrames,
+          [...pathPrefix, "children", String(i)],
+          errors
+        );
+      }
+    }
+  }
+};
+
+// src/core/engine.ts
+var import_bundler = require("@remotion/bundler");
+var import_renderer = require("@remotion/renderer");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+
+// src/utils/errors.ts
+var WavesError = class _WavesError extends Error {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+    this.name = "WavesError";
+    Object.setPrototypeOf(this, _WavesError.prototype);
+  }
+};
+var WavesRenderError = class _WavesRenderError extends WavesError {
+  constructor(message, context) {
+    super(message, context);
+    this.name = "WavesRenderError";
+    Object.setPrototypeOf(this, _WavesRenderError.prototype);
+  }
+};
+
+// src/core/engine.ts
+var WavesEngine = class {
+  constructor(registry, validator) {
+    this.registry = registry;
+    this.validator = validator;
+  }
+  async render(ir, options) {
+    if (this.registry !== globalRegistry) {
+      throw new WavesRenderError("WavesEngine currently requires using globalRegistry", {
+        hint: "Use `registerBuiltInComponents()` + `globalRegistry` for both validation and rendering."
+      });
+    }
+    const validationResult = this.validator.validate(ir);
+    if (!validationResult.success) {
+      throw new WavesRenderError("IR validation failed", { errors: validationResult.errors });
+    }
+    const validatedIR = validationResult.data;
+    const requiredTypes = collectComponentTypes(validatedIR);
+    for (const type of requiredTypes) {
+      if (!this.registry.has(type)) {
+        throw new WavesRenderError("Unknown component type", { type });
+      }
+    }
+    const rootDir = options.rootDir ?? process.cwd();
+    const tmpDir = await import_promises.default.mkdtemp(import_node_path.default.join(rootDir, ".waves-tmp-"));
+    const entryPoint = import_node_path.default.join(tmpDir, "entry.tsx");
+    try {
+      await import_promises.default.writeFile(entryPoint, generateEntryPoint(validatedIR, options), "utf-8");
+      await import_promises.default.mkdir(import_node_path.default.dirname(options.outputPath), { recursive: true });
+      const bundleLocation = await (0, import_bundler.bundle)({
+        entryPoint,
+        rootDir,
+        publicDir: options.publicDir ?? null,
+        onProgress: () => void 0
+      });
+      const compositionId = validatedIR.video.id ?? "main";
+      const composition = await (0, import_renderer.selectComposition)({
+        serveUrl: bundleLocation,
+        id: compositionId,
+        inputProps: {}
+      });
+      await (0, import_renderer.renderMedia)({
+        composition,
+        serveUrl: bundleLocation,
+        codec: options.codec ?? "h264",
+        outputLocation: options.outputPath,
+        crf: options.crf ?? null,
+        concurrency: options.concurrency ?? null,
+        overwrite: true
+      });
+    } catch (error) {
+      throw new WavesRenderError("Rendering failed", { originalError: error });
+    } finally {
+      await import_promises.default.rm(tmpDir, { recursive: true, force: true });
+    }
+  }
+};
+function collectComponentTypes(ir) {
+  const types = /* @__PURE__ */ new Set();
+  for (const scene of ir.scenes) {
+    walkComponent(scene, types);
+  }
+  return types;
+}
+function walkComponent(component, types) {
+  types.add(component.type);
+  const children = component.children;
+  if (children) {
+    for (const child of children) {
+      walkComponent(child, types);
+    }
+  }
+}
+function generateEntryPoint(ir, options) {
+  const compositionId = ir.video.id ?? "main";
+  const width = ir.video.width;
+  const height = ir.video.height;
+  const fps = ir.video.fps ?? 30;
+  const durationInFrames = ir.video.durationInFrames;
+  const registrationImports = (options.registrationModules ?? []).map((m) => `import ${JSON.stringify(m)};`).join("\n");
+  return `import React from 'react';
+import { Composition, registerRoot } from 'remotion';
+import { WavesComposition, globalRegistry, registerBuiltInComponents } from '@depths/waves/remotion';
+${registrationImports}
+
+registerBuiltInComponents();
+
+const ir = ${JSON.stringify(ir, null, 2)};
+const compositionId = ${JSON.stringify(compositionId)};
+
+const Root = () => {
+  return <WavesComposition ir={ir} registry={globalRegistry} />;
+};
+
+export const RemotionRoot = () => {
+  return (
+    <Composition
+      id={compositionId}
+      component={Root}
+      durationInFrames={${durationInFrames}}
+      fps={${fps}}
+      width={${width}}
+      height={${height}}
+    />
+  );
+};
+
+registerRoot(RemotionRoot);
+`;
+}
+
+// src/cli.ts
+var EXIT_OK = 0;
+var EXIT_USAGE = 1;
+var EXIT_VALIDATE = 2;
+var EXIT_RENDER = 3;
+var EXIT_IO = 4;
+var EXIT_INTERNAL = 5;
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  let command = null;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i] ?? "";
+    if (!command && !arg.startsWith("-")) {
+      command = arg;
+      continue;
+    }
+    if (arg === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      const key = (eq >= 0 ? arg.slice(2, eq) : arg.slice(2)).trim();
+      const hasInlineValue = eq >= 0;
+      const inlineValue = hasInlineValue ? arg.slice(eq + 1) : void 0;
+      const next = argv[i + 1];
+      const isBoolean = key === "help" || key === "pretty";
+      if (isBoolean) {
+        flags[key] = true;
+        continue;
+      }
+      const value = inlineValue ?? (next && !next.startsWith("-") ? (i++, next) : void 0);
+      if (value === void 0) {
+        flags[key] = true;
+        continue;
+      }
+      const existing = flags[key];
+      if (existing === void 0) {
+        flags[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        flags[key] = [String(existing), value];
+      }
+      continue;
+    }
+    if (arg === "-h" || arg === "--help") {
+      flags.help = true;
+      continue;
+    }
+    if (arg === "-v" || arg === "--version") {
+      flags.version = true;
+      continue;
+    }
+    positionals.push(arg);
+  }
+  return { command, positionals, flags };
+}
+function formatHelp() {
+  return `waves v${__wavesVersion}
+
+Usage:
+  waves <command> [options]
+
+Commands:
+  prompt      Print an agent-ready system prompt + schema payload
+  schema      Print JSON Schemas for IR/components
+  write-ir    Write a starter IR JSON file
+  validate    Validate an IR JSON file
+  render      Render MP4 from an IR JSON file
+
+Options:
+  -h, --help       Show help
+  -v, --version    Show version
+`;
+}
+function getFlagString(flags, key) {
+  const v = flags[key];
+  if (typeof v === "string") return v;
+  if (Array.isArray(v)) return String(v[v.length - 1]);
+  return void 0;
+}
+function getFlagStrings(flags, key) {
+  const v = flags[key];
+  if (typeof v === "string") return [v];
+  if (Array.isArray(v)) return v.map(String);
+  return [];
+}
+async function tryWriteOut(outPath, content) {
+  if (!outPath) return null;
+  try {
+    await import_promises2.default.mkdir(import_node_path2.default.dirname(outPath), { recursive: true });
+    await import_promises2.default.writeFile(outPath, content, "utf-8");
+    return null;
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+}
+async function importRegistrationModules(modules) {
+  for (const m of modules) {
+    await import(m);
+  }
+}
+function stringifyJSON(value, pretty) {
+  return JSON.stringify(value, null, pretty ? 2 : 0) + "\n";
+}
+function collectComponentTypes2(ir) {
+  const types = /* @__PURE__ */ new Set();
+  for (const scene of ir.scenes) {
+    walkComponent2(scene, types);
+  }
+  return types;
+}
+function walkComponent2(component, types) {
+  types.add(component.type);
+  const children = component.children;
+  if (children?.length) {
+    for (const child of children) {
+      walkComponent2(child, types);
+    }
+  }
+}
+async function main(argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv);
+  if (parsed.flags.version) {
+    process.stdout.write(`${__wavesVersion}
+`);
+    return EXIT_OK;
+  }
+  if (parsed.flags.help || !parsed.command) {
+    process.stdout.write(formatHelp());
+    return EXIT_OK;
+  }
+  if (parsed.command === "help") {
+    process.stdout.write(formatHelp());
+    return EXIT_OK;
+  }
+  const outPath = getFlagString(parsed.flags, "out");
+  const pretty = Boolean(parsed.flags.pretty);
+  const registrationModules = getFlagStrings(parsed.flags, "register");
+  try {
+    await importRegistrationModules(registrationModules);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`Failed to import --register module: ${message}
+`);
+    return EXIT_USAGE;
+  }
+  registerBuiltInComponents();
+  if (parsed.command === "prompt") {
+    const format = (getFlagString(parsed.flags, "format") ?? "text").toLowerCase();
+    const maxCharsRaw = getFlagString(parsed.flags, "maxChars");
+    const maxChars = maxCharsRaw ? Number(maxCharsRaw) : void 0;
+    const payload = getPromptPayload({ registry: globalRegistry });
+    if (format === "json") {
+      const json = stringifyJSON(payload, pretty);
+      const writeErr = await tryWriteOut(outPath, json);
+      if (writeErr) {
+        process.stderr.write(`Failed to write ${outPath}: ${writeErr}
+`);
+        process.stdout.write(json);
+        return EXIT_IO;
+      }
+      process.stdout.write(json);
+      if (outPath) process.stderr.write(`Wrote ${outPath}
+`);
+      return EXIT_OK;
+    }
+    if (format === "text") {
+      const text = typeof maxChars === "number" && Number.isFinite(maxChars) && maxChars > 0 ? payload.systemPrompt.slice(0, maxChars) : payload.systemPrompt;
+      const out = text.endsWith("\n") ? text : `${text}
+`;
+      const writeErr = await tryWriteOut(outPath, out);
+      if (writeErr) {
+        process.stderr.write(`Failed to write ${outPath}: ${writeErr}
+`);
+        process.stdout.write(out);
+        return EXIT_IO;
+      }
+      process.stdout.write(out);
+      if (outPath) process.stderr.write(`Wrote ${outPath}
+`);
+      return EXIT_OK;
+    }
+    process.stderr.write(`Invalid --format: ${format} (expected "text" or "json")
+`);
+    return EXIT_USAGE;
+  }
+  if (parsed.command === "schema") {
+    const kind = (getFlagString(parsed.flags, "kind") ?? "all").toLowerCase();
+    let output;
+    if (kind === "video-ir") {
+      output = zodSchemaToJsonSchema(VideoIRSchema);
+    } else if (kind === "components") {
+      output = globalRegistry.getJSONSchemaForLLM();
+    } else if (kind === "all") {
+      output = {
+        videoIR: zodSchemaToJsonSchema(VideoIRSchema),
+        components: globalRegistry.getJSONSchemaForLLM()
+      };
+    } else {
+      process.stderr.write(`Invalid --kind: ${kind} (expected video-ir|components|all)
+`);
+      return EXIT_USAGE;
+    }
+    const json = stringifyJSON(output, pretty);
+    const writeErr = await tryWriteOut(outPath, json);
+    if (writeErr) {
+      process.stderr.write(`Failed to write ${outPath}: ${writeErr}
+`);
+      process.stdout.write(json);
+      return EXIT_IO;
+    }
+    process.stdout.write(json);
+    if (outPath) process.stderr.write(`Wrote ${outPath}
+`);
+    return EXIT_OK;
+  }
+  if (parsed.command === "write-ir") {
+    const template = (getFlagString(parsed.flags, "template") ?? "minimal").toLowerCase();
+    const out = outPath;
+    if (!out) {
+      process.stderr.write("Missing required --out <path>\n");
+      return EXIT_USAGE;
+    }
+    const ir = template === "basic" ? {
+      version: "1.0",
+      video: { id: "main", width: 1920, height: 1080, fps: 30, durationInFrames: 90 },
+      scenes: [
+        {
+          id: "scene-1",
+          type: "Scene",
+          timing: { from: 0, durationInFrames: 90 },
+          props: { background: { type: "color", value: "#000000" } },
+          children: [
+            {
+              id: "title",
+              type: "Text",
+              timing: { from: 0, durationInFrames: 90 },
+              props: { content: "Hello Waves", fontSize: 72, animation: "fade" }
+            }
+          ]
+        }
+      ]
+    } : template === "minimal" ? {
+      version: "1.0",
+      video: { id: "main", width: 1920, height: 1080, fps: 30, durationInFrames: 60 },
+      scenes: [
+        {
+          id: "scene-1",
+          type: "Scene",
+          timing: { from: 0, durationInFrames: 60 },
+          props: { background: { type: "color", value: "#000000" } }
+        }
+      ]
+    } : null;
+    if (!ir) {
+      process.stderr.write(`Invalid --template: ${template} (expected minimal|basic)
+`);
+      return EXIT_USAGE;
+    }
+    const schemaCheck = VideoIRSchema.safeParse(ir);
+    if (!schemaCheck.success) {
+      process.stderr.write("Internal error: generated template does not validate against VideoIRSchema\n");
+      return EXIT_INTERNAL;
+    }
+    const json = stringifyJSON(ir, pretty);
+    const writeErr = await tryWriteOut(out, json);
+    if (writeErr) {
+      process.stderr.write(`Failed to write ${out}: ${writeErr}
+`);
+      return EXIT_IO;
+    }
+    process.stdout.write(json);
+    process.stderr.write(`Wrote ${out}
+`);
+    return EXIT_OK;
+  }
+  if (parsed.command === "validate") {
+    const inputPath = getFlagString(parsed.flags, "in");
+    if (!inputPath) {
+      process.stderr.write("Missing required --in <path>\n");
+      return EXIT_USAGE;
+    }
+    const format = (getFlagString(parsed.flags, "format") ?? "text").toLowerCase();
+    if (format !== "text" && format !== "json") {
+      process.stderr.write(`Invalid --format: ${format} (expected "text" or "json")
+`);
+      return EXIT_USAGE;
+    }
+    let raw;
+    try {
+      raw = await import_promises2.default.readFile(inputPath, "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Failed to read ${inputPath}: ${message}
+`);
+      return EXIT_IO;
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (format === "json") {
+        process.stdout.write(
+          stringifyJSON(
+            { success: false, errors: [{ path: ["<file>"], message, code: "INVALID_JSON" }] },
+            pretty
+          )
+        );
+      } else {
+        process.stderr.write(`Invalid JSON: ${message}
+`);
+      }
+      return EXIT_VALIDATE;
+    }
+    const validator = new IRValidator();
+    const result = validator.validate(json);
+    const errors = result.success ? [] : result.errors;
+    if (result.success) {
+      const types = collectComponentTypes2(result.data);
+      const unknownTypes = [...types].filter((t) => !globalRegistry.has(t)).sort();
+      for (const t of unknownTypes) {
+        errors.push({
+          path: ["components", t],
+          message: `Unknown component type: ${t}`,
+          code: "UNKNOWN_COMPONENT_TYPE"
+        });
+      }
+    }
+    const ok = errors.length === 0;
+    if (format === "json") {
+      process.stdout.write(stringifyJSON(ok ? { success: true } : { success: false, errors }, pretty));
+    } else {
+      if (ok) {
+        process.stdout.write("ok\n");
+      } else {
+        process.stderr.write("validation failed\n");
+        for (const e of errors) {
+          process.stderr.write(`- ${e.code} ${e.path.join(".")}: ${e.message}
+`);
+        }
+      }
+    }
+    return ok ? EXIT_OK : EXIT_VALIDATE;
+  }
+  if (parsed.command === "render") {
+    const inputPath = getFlagString(parsed.flags, "in");
+    const outputPath = outPath;
+    if (!inputPath) {
+      process.stderr.write("Missing required --in <path>\n");
+      return EXIT_USAGE;
+    }
+    if (!outputPath) {
+      process.stderr.write("Missing required --out <path>\n");
+      return EXIT_USAGE;
+    }
+    let raw;
+    try {
+      raw = await import_promises2.default.readFile(inputPath, "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Failed to read ${inputPath}: ${message}
+`);
+      return EXIT_IO;
+    }
+    let json;
+    try {
+      json = JSON.parse(raw);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`Invalid JSON: ${message}
+`);
+      return EXIT_VALIDATE;
+    }
+    const codec = getFlagString(parsed.flags, "codec");
+    const crfRaw = getFlagString(parsed.flags, "crf");
+    const concurrencyRaw = getFlagString(parsed.flags, "concurrency");
+    const publicDir = getFlagString(parsed.flags, "publicDir");
+    const crf = crfRaw ? Number(crfRaw) : void 0;
+    const concurrency = concurrencyRaw ? /^[0-9]+$/.test(concurrencyRaw) ? Number(concurrencyRaw) : concurrencyRaw : void 0;
+    const engine = new WavesEngine(globalRegistry, new IRValidator());
+    try {
+      const opts = { outputPath, registrationModules };
+      if (publicDir) opts.publicDir = publicDir;
+      if (codec) opts.codec = codec;
+      if (Number.isFinite(crf ?? Number.NaN)) opts.crf = crf;
+      if (concurrency !== void 0) opts.concurrency = concurrency;
+      await engine.render(json, opts);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const context = err instanceof WavesRenderError ? err.context : void 0;
+      const payload = context ? stringifyJSON({ error: message, context }, pretty) : null;
+      process.stderr.write(`render failed: ${message}
+`);
+      if (payload) process.stderr.write(payload);
+      return EXIT_RENDER;
+    }
+    process.stderr.write(`Rendered ${outputPath}
+`);
+    return EXIT_OK;
+  }
+  process.stderr.write(`Unknown command: ${parsed.command}
+`);
+  process.stderr.write(`Run: waves --help
+`);
+  return EXIT_USAGE;
+}
+var req = typeof require !== "undefined" ? require : void 0;
+var isCjsMain = typeof req !== "undefined" && typeof module !== "undefined" && req.main === module;
+if (isCjsMain) {
+  main().then((code) => process.exit(code)).catch((err) => {
+    const message = err instanceof Error ? err.stack ?? err.message : String(err);
+    process.stderr.write(`${message}
+`);
+    process.exit(EXIT_INTERNAL);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});