@depths/waves 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,440 @@
+import {
+  IRValidator,
+  WavesEngine,
+  __wavesVersion,
+  getPromptPayload
+} from "./chunk-WGQITADJ.mjs";
+import {
+  VideoIRSchema,
+  WavesRenderError,
+  __require,
+  globalRegistry,
+  registerBuiltInComponents,
+  zodSchemaToJsonSchema
+} from "./chunk-TGAL5RQN.mjs";
+
+// src/cli.ts
+import fs from "fs/promises";
+import path from "path";
+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 fs.mkdir(path.dirname(outPath), { recursive: true });
+    await fs.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 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?.length) {
+    for (const child of children) {
+      walkComponent(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 fs.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 = collectComponentTypes(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 fs.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);
+  });
+}
+export {
+  main
+};

package/dist/index.d.mts

@@ -0,0 +1,89 @@
+import { V as VideoIR, C as ComponentRegistry } from './registry-hVIyqwS6.mjs';
+export { A as AssetPathSchema, a as AudioComponentIRSchema, b as AudioIR, B as BackgroundSpec, c as BackgroundSpecSchema, d as BaseComponentIR, e as BaseComponentIRSchema, f as ComponentIR, g as ComponentIRSchema, h as ComponentSchemas, S as SceneComponentIRSchema, i as SceneIR, T as TextComponentIRSchema, j as TextIR, k as TimingSpec, l as TimingSpecSchema, m as VideoIRSchema, n as globalRegistry, r as registerBuiltInComponents } from './registry-hVIyqwS6.mjs';
+import 'zod';
+import 'react';
+
+declare const __wavesVersion = "0.1.0";
+
+interface ValidationError {
+    path: string[];
+    message: string;
+    code: string;
+}
+interface ValidationResult {
+    success: boolean;
+    errors?: ValidationError[];
+}
+declare class IRValidator {
+    validateSchema(ir: unknown): {
+        success: true;
+        data: VideoIR;
+    } | {
+        success: false;
+        errors: ValidationError[];
+    };
+    validateSemantics(ir: VideoIR): ValidationResult;
+    validate(ir: unknown): {
+        success: true;
+        data: VideoIR;
+    } | {
+        success: false;
+        errors: ValidationError[];
+    };
+    private validateComponentTimingRecursive;
+}
+
+interface RenderOptions {
+    outputPath: string;
+    codec?: 'h264' | 'h265' | 'vp8' | 'vp9';
+    crf?: number;
+    concurrency?: number | string;
+    publicDir?: string;
+    rootDir?: string;
+    registrationModules?: string[];
+}
+declare class WavesEngine {
+    private readonly registry;
+    private readonly validator;
+    constructor(registry: ComponentRegistry, validator: IRValidator);
+    render(ir: unknown, options: RenderOptions): Promise<void>;
+}
+
+declare class WavesError extends Error {
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, context?: Record<string, unknown> | undefined);
+}
+declare class WavesValidationError extends WavesError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+declare class WavesRenderError extends WavesError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+
+type PromptPayload = {
+    package: '@depths/waves';
+    version: string;
+    irVersion: '1.0';
+    systemPrompt: string;
+    schemas: {
+        videoIR: Record<string, unknown>;
+        components: Record<string, unknown>;
+    };
+    rules: {
+        timing: string[];
+        assets: string[];
+        ids: string[];
+        output: string[];
+    };
+};
+declare function getSystemPrompt(registeredTypes: string[]): string;
+declare function getPromptPayload(options?: {
+    registry?: ComponentRegistry;
+}): PromptPayload;
+
+declare function renderVideo(ir: unknown, options: {
+    outputPath: string;
+    publicDir?: string;
+}): Promise<void>;
+
+export { ComponentRegistry, IRValidator, type PromptPayload, VideoIR, WavesEngine, WavesError, WavesRenderError, WavesValidationError, __wavesVersion, getPromptPayload, getSystemPrompt, renderVideo };

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+import { V as VideoIR, C as ComponentRegistry } from './registry-hVIyqwS6.js';
+export { A as AssetPathSchema, a as AudioComponentIRSchema, b as AudioIR, B as BackgroundSpec, c as BackgroundSpecSchema, d as BaseComponentIR, e as BaseComponentIRSchema, f as ComponentIR, g as ComponentIRSchema, h as ComponentSchemas, S as SceneComponentIRSchema, i as SceneIR, T as TextComponentIRSchema, j as TextIR, k as TimingSpec, l as TimingSpecSchema, m as VideoIRSchema, n as globalRegistry, r as registerBuiltInComponents } from './registry-hVIyqwS6.js';
+import 'zod';
+import 'react';
+
+declare const __wavesVersion = "0.1.0";
+
+interface ValidationError {
+    path: string[];
+    message: string;
+    code: string;
+}
+interface ValidationResult {
+    success: boolean;
+    errors?: ValidationError[];
+}
+declare class IRValidator {
+    validateSchema(ir: unknown): {
+        success: true;
+        data: VideoIR;
+    } | {
+        success: false;
+        errors: ValidationError[];
+    };
+    validateSemantics(ir: VideoIR): ValidationResult;
+    validate(ir: unknown): {
+        success: true;
+        data: VideoIR;
+    } | {
+        success: false;
+        errors: ValidationError[];
+    };
+    private validateComponentTimingRecursive;
+}
+
+interface RenderOptions {
+    outputPath: string;
+    codec?: 'h264' | 'h265' | 'vp8' | 'vp9';
+    crf?: number;
+    concurrency?: number | string;
+    publicDir?: string;
+    rootDir?: string;
+    registrationModules?: string[];
+}
+declare class WavesEngine {
+    private readonly registry;
+    private readonly validator;
+    constructor(registry: ComponentRegistry, validator: IRValidator);
+    render(ir: unknown, options: RenderOptions): Promise<void>;
+}
+
+declare class WavesError extends Error {
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, context?: Record<string, unknown> | undefined);
+}
+declare class WavesValidationError extends WavesError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+declare class WavesRenderError extends WavesError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+
+type PromptPayload = {
+    package: '@depths/waves';
+    version: string;
+    irVersion: '1.0';
+    systemPrompt: string;
+    schemas: {
+        videoIR: Record<string, unknown>;
+        components: Record<string, unknown>;
+    };
+    rules: {
+        timing: string[];
+        assets: string[];
+        ids: string[];
+        output: string[];
+    };
+};
+declare function getSystemPrompt(registeredTypes: string[]): string;
+declare function getPromptPayload(options?: {
+    registry?: ComponentRegistry;
+}): PromptPayload;
+
+declare function renderVideo(ir: unknown, options: {
+    outputPath: string;
+    publicDir?: string;
+}): Promise<void>;
+
+export { ComponentRegistry, IRValidator, type PromptPayload, VideoIR, WavesEngine, WavesError, WavesRenderError, WavesValidationError, __wavesVersion, getPromptPayload, getSystemPrompt, renderVideo };