@depths/waves 0.1.0

package/dist/index.js

@@ -0,0 +1,728 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ComponentRegistry: () => ComponentRegistry,
+  ComponentSchemas: () => ComponentSchemas,
+  IRValidator: () => IRValidator,
+  VideoIRSchema: () => VideoIRSchema,
+  WavesEngine: () => WavesEngine,
+  WavesError: () => WavesError,
+  WavesRenderError: () => WavesRenderError,
+  WavesValidationError: () => WavesValidationError,
+  __wavesVersion: () => __wavesVersion,
+  getPromptPayload: () => getPromptPayload,
+  getSystemPrompt: () => getSystemPrompt,
+  globalRegistry: () => globalRegistry,
+  registerBuiltInComponents: () => registerBuiltInComponents,
+  renderVideo: () => renderVideo
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/version.ts
+var __wavesVersion = "0.1.0";
+
+// 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/json-schema.ts
+var import_zod = require("zod");
+function zodSchemaToJsonSchema(schema) {
+  return import_zod.z.toJSONSchema(schema);
+}
+
+// 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/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 WavesValidationError = class _WavesValidationError extends WavesError {
+  constructor(message, context) {
+    super(message, context);
+    this.name = "WavesValidationError";
+    Object.setPrototypeOf(this, _WavesValidationError.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/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(
+  (path2) => path2.startsWith("/") || path2.startsWith("http://") || path2.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)
+});
+var ComponentSchemas = {
+  Scene: SceneComponentIRSchema,
+  Text: TextComponentIRSchema,
+  Audio: AudioComponentIRSchema
+};
+
+// 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/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/index.ts
+async function renderVideo(ir, options) {
+  registerBuiltInComponents();
+  const engine = new WavesEngine(globalRegistry, new IRValidator());
+  await engine.render(ir, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ComponentRegistry,
+  ComponentSchemas,
+  IRValidator,
+  VideoIRSchema,
+  WavesEngine,
+  WavesError,
+  WavesRenderError,
+  WavesValidationError,
+  __wavesVersion,
+  getPromptPayload,
+  getSystemPrompt,
+  globalRegistry,
+  registerBuiltInComponents,
+  renderVideo
+});