@depths/waves 0.1.0

package/dist/remotion/index.js

@@ -0,0 +1,468 @@
+"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/remotion/index.ts
+var remotion_exports = {};
+__export(remotion_exports, {
+  WavesComposition: () => WavesComposition,
+  globalRegistry: () => globalRegistry,
+  registerBuiltInComponents: () => registerBuiltInComponents
+});
+module.exports = __toCommonJS(remotion_exports);
+
+// src/remotion/WavesComposition.tsx
+var import_react = __toESM(require("react"));
+var import_remotion = require("remotion");
+
+// 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/remotion/WavesComposition.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var WavesComposition = ({ ir, registry }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: ir.scenes.map((scene) => renderComponent(scene, registry)) });
+};
+var getProps = (component) => {
+  return component.props ?? {};
+};
+var getChildren = (component) => {
+  return component.children;
+};
+function renderComponent(component, registry) {
+  const registration = registry.get(component.type);
+  if (!registration) {
+    throw new WavesRenderError("Unknown component type", { type: component.type });
+  }
+  const propsValidation = registry.validateProps(component.type, getProps(component));
+  if (!propsValidation.success) {
+    throw new WavesRenderError("Component props validation failed", {
+      type: component.type,
+      issues: propsValidation.error.issues
+    });
+  }
+  const parsedProps = propsValidation.data;
+  if (!parsedProps || typeof parsedProps !== "object") {
+    throw new WavesRenderError("Component props must be an object", { type: component.type });
+  }
+  const children = component.type === "Scene" && getChildren(component)?.length ? getChildren(component).map((child) => renderComponent(child, registry)) : null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_remotion.Sequence,
+    {
+      from: component.timing.from,
+      durationInFrames: component.timing.durationInFrames,
+      children: import_react.default.createElement(
+        registration.component,
+        {
+          ...parsedProps,
+          __wavesDurationInFrames: component.timing.durationInFrames
+        },
+        children
+      )
+    },
+    component.id
+  );
+}
+
+// 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/components/primitives/Audio.tsx
+var import_remotion2 = require("remotion");
+var import_zod2 = 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_runtime2 = require("react/jsx-runtime");
+var AudioPropsSchema = import_zod2.z.object({
+  src: import_zod2.z.string(),
+  volume: import_zod2.z.number().min(0).max(1).default(1),
+  startFrom: import_zod2.z.number().int().min(0).default(0),
+  fadeIn: import_zod2.z.number().int().min(0).default(0),
+  fadeOut: import_zod2.z.number().int().min(0).default(0)
+});
+var Audio = ({
+  src,
+  volume,
+  startFrom,
+  fadeIn,
+  fadeOut,
+  __wavesDurationInFrames
+}) => {
+  const frame = (0, import_remotion2.useCurrentFrame)();
+  const durationInFrames = __wavesDurationInFrames ?? Number.POSITIVE_INFINITY;
+  const fadeInFactor = fadeIn > 0 ? (0, import_remotion2.interpolate)(frame, [0, fadeIn], [0, 1], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  }) : 1;
+  const fadeOutStart = durationInFrames - fadeOut;
+  const fadeOutFactor = fadeOut > 0 ? (0, import_remotion2.interpolate)(frame, [fadeOutStart, durationInFrames], [1, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp"
+  }) : 1;
+  const resolvedSrc = isRemoteAssetPath(src) ? src : (0, import_remotion2.staticFile)(staticFileInputFromAssetPath(src));
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    import_remotion2.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_remotion3 = require("remotion");
+var import_zod4 = require("zod");
+
+// src/ir/schema.ts
+var import_zod3 = require("zod");
+var TimingSpecSchema = import_zod3.z.object({
+  from: import_zod3.z.number().int().min(0).describe("Start frame (0-indexed)"),
+  durationInFrames: import_zod3.z.number().int().positive().describe("Duration in frames")
+});
+var AssetPathSchema = import_zod3.z.string().refine(
+  (path) => path.startsWith("/") || path.startsWith("http://") || path.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_zod3.z.discriminatedUnion("type", [
+  import_zod3.z.object({
+    type: import_zod3.z.literal("color"),
+    value: import_zod3.z.string().regex(/^#[0-9A-Fa-f]{6}$/, "Must be valid hex color")
+  }),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("image"),
+    value: AssetPathSchema
+  }),
+  import_zod3.z.object({
+    type: import_zod3.z.literal("video"),
+    value: AssetPathSchema
+  })
+]);
+var BaseComponentIRSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1).max(100).describe("Unique component instance ID"),
+  type: import_zod3.z.string().min(1).describe("Component type identifier"),
+  timing: TimingSpecSchema,
+  metadata: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown()).optional().describe("Optional metadata")
+});
+var TextComponentIRSchema = BaseComponentIRSchema.extend({
+  type: import_zod3.z.literal("Text"),
+  props: import_zod3.z.object({
+    content: import_zod3.z.string().min(1).max(1e3),
+    fontSize: import_zod3.z.number().int().min(12).max(200).default(48),
+    color: import_zod3.z.string().regex(/^#[0-9A-Fa-f]{6}$/).default("#FFFFFF"),
+    position: import_zod3.z.enum(["top", "center", "bottom", "left", "right"]).default("center"),
+    animation: import_zod3.z.enum(["none", "fade", "slide", "zoom"]).default("fade")
+  })
+});
+var AudioComponentIRSchema = BaseComponentIRSchema.extend({
+  type: import_zod3.z.literal("Audio"),
+  props: import_zod3.z.object({
+    src: AssetPathSchema,
+    volume: import_zod3.z.number().min(0).max(1).default(1),
+    startFrom: import_zod3.z.number().int().min(0).default(0).describe("Start playback from frame N"),
+    fadeIn: import_zod3.z.number().int().min(0).default(0).describe("Fade in duration in frames"),
+    fadeOut: import_zod3.z.number().int().min(0).default(0).describe("Fade out duration in frames")
+  })
+});
+function getComponentIRSchema() {
+  return ComponentIRSchema;
+}
+var SceneComponentIRSchema = BaseComponentIRSchema.extend({
+  type: import_zod3.z.literal("Scene"),
+  props: import_zod3.z.object({
+    background: BackgroundSpecSchema
+  }),
+  children: import_zod3.z.lazy(() => import_zod3.z.array(getComponentIRSchema())).optional()
+});
+var ComponentIRSchema = import_zod3.z.discriminatedUnion("type", [
+  SceneComponentIRSchema,
+  TextComponentIRSchema,
+  AudioComponentIRSchema
+]);
+var VideoIRSchema = import_zod3.z.object({
+  version: import_zod3.z.literal("1.0").describe("IR schema version"),
+  video: import_zod3.z.object({
+    id: import_zod3.z.string().default("main"),
+    width: import_zod3.z.number().int().min(360).max(7680),
+    height: import_zod3.z.number().int().min(360).max(4320),
+    fps: import_zod3.z.number().int().min(1).max(120).default(30),
+    durationInFrames: import_zod3.z.number().int().positive()
+  }),
+  audio: import_zod3.z.object({
+    background: AssetPathSchema.optional(),
+    volume: import_zod3.z.number().min(0).max(1).default(0.5)
+  }).optional(),
+  scenes: import_zod3.z.array(SceneComponentIRSchema).min(1)
+});
+
+// src/components/primitives/Scene.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var ScenePropsSchema = import_zod4.z.object({
+  background: BackgroundSpecSchema
+});
+var resolveAsset = (value) => {
+  return isRemoteAssetPath(value) ? value : (0, import_remotion3.staticFile)(staticFileInputFromAssetPath(value));
+};
+var Scene = ({ background, children }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_remotion3.AbsoluteFill, { children: [
+    background.type === "color" ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_remotion3.AbsoluteFill, { style: { backgroundColor: background.value } }) : background.type === "image" ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_remotion3.Img,
+      {
+        src: resolveAsset(background.value),
+        style: { width: "100%", height: "100%", objectFit: "cover" }
+      }
+    ) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_remotion3.Video,
+      {
+        src: resolveAsset(background.value),
+        style: { width: "100%", height: "100%", objectFit: "cover" }
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_remotion3.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_remotion4 = require("remotion");
+var import_zod5 = require("zod");
+var import_jsx_runtime4 = 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_remotion4.interpolate)(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { opacity };
+    }
+    case "slide": {
+      const translateY = (0, import_remotion4.interpolate)(frame, [0, animDuration], [50, 0], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      const opacity = (0, import_remotion4.interpolate)(frame, [0, animDuration], [0, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      return { transform: `translateY(${translateY}px)`, opacity };
+    }
+    case "zoom": {
+      const scale = (0, import_remotion4.interpolate)(frame, [0, animDuration], [0.8, 1], {
+        extrapolateLeft: "clamp",
+        extrapolateRight: "clamp"
+      });
+      const opacity = (0, import_remotion4.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_remotion4.useCurrentFrame)();
+  const positionStyles = getPositionStyles(position);
+  const animationStyles = getAnimationStyle(frame, animation);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_remotion4.AbsoluteFill, { style: positionStyles, children: /* @__PURE__ */ (0, import_jsx_runtime4.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
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WavesComposition,
+  globalRegistry,
+  registerBuiltInComponents
+});

package/dist/remotion/index.mjs

@@ -0,0 +1,58 @@
+import {
+  WavesRenderError,
+  globalRegistry,
+  registerBuiltInComponents
+} from "../chunk-TGAL5RQN.mjs";
+
+// src/remotion/WavesComposition.tsx
+import React from "react";
+import { Sequence } from "remotion";
+import { Fragment, jsx } from "react/jsx-runtime";
+var WavesComposition = ({ ir, registry }) => {
+  return /* @__PURE__ */ jsx(Fragment, { children: ir.scenes.map((scene) => renderComponent(scene, registry)) });
+};
+var getProps = (component) => {
+  return component.props ?? {};
+};
+var getChildren = (component) => {
+  return component.children;
+};
+function renderComponent(component, registry) {
+  const registration = registry.get(component.type);
+  if (!registration) {
+    throw new WavesRenderError("Unknown component type", { type: component.type });
+  }
+  const propsValidation = registry.validateProps(component.type, getProps(component));
+  if (!propsValidation.success) {
+    throw new WavesRenderError("Component props validation failed", {
+      type: component.type,
+      issues: propsValidation.error.issues
+    });
+  }
+  const parsedProps = propsValidation.data;
+  if (!parsedProps || typeof parsedProps !== "object") {
+    throw new WavesRenderError("Component props must be an object", { type: component.type });
+  }
+  const children = component.type === "Scene" && getChildren(component)?.length ? getChildren(component).map((child) => renderComponent(child, registry)) : null;
+  return /* @__PURE__ */ jsx(
+    Sequence,
+    {
+      from: component.timing.from,
+      durationInFrames: component.timing.durationInFrames,
+      children: React.createElement(
+        registration.component,
+        {
+          ...parsedProps,
+          __wavesDurationInFrames: component.timing.durationInFrames
+        },
+        children
+      )
+    },
+    component.id
+  );
+}
+export {
+  WavesComposition,
+  globalRegistry,
+  registerBuiltInComponents
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@depths/waves",
+  "version": "0.1.0",
+  "description": "Type-safe video generation engine for converting JSON IR to rendered videos using Remotion",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "waves": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    },
+    "./remotion": {
+      "types": "./dist/remotion/index.d.ts",
+      "require": "./dist/remotion/index.js",
+      "import": "./dist/remotion/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/remotion/index.ts src/cli.ts --format cjs,esm --dts --clean && node scripts/add-shebang.mjs dist/cli.js",
+    "dev": "tsup src/index.ts src/remotion/index.ts src/cli.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm run test && npm run typecheck"
+  },
+  "keywords": [
+    "remotion",
+    "video",
+    "generation",
+    "llm",
+    "json",
+    "ir",
+    "typescript",
+    "zod"
+  ],
+  "author": "Depths AI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/depths-ai/waves.git"
+  },
+  "engines": {
+    "node": ">=22.11.0 <25.0.0"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "remotion": "4.0.407"
+  },
+  "dependencies": {
+    "@remotion/bundler": "4.0.407",
+    "@remotion/cli": "4.0.407",
+    "@remotion/renderer": "4.0.407",
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@types/react": "^19.0.6",
+    "@typescript-eslint/eslint-plugin": "^8.21.0",
+    "@typescript-eslint/parser": "^8.21.0",
+    "eslint": "^9.18.0",
+    "react": "^19.0.0",
+    "remotion": "4.0.407",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.21.0",
+    "vitest": "^4.0.18"
+  }
+}