cinematic-renderer2d 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1243 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { z } from 'zod';
+
+// src/cli/index.ts
+
+// src/animation/AnimationCompiler.ts
+var AnimationCompiler = class {
+  /**
+   * Compiles an animation track specification into an optimized runtime track
+   * 
+   * @param track - Animation track specification to compile
+   * @returns Compiled animation track with precompiled interpolation function
+   */
+  static compileTrack(track) {
+    const easingFunction = this.compileEasing(track.easing || "ease");
+    const interpolationFunction = this.compileInterpolation(track.from, track.to, easingFunction);
+    return {
+      property: track.property,
+      startMs: track.startMs,
+      endMs: track.endMs,
+      interpolate: interpolationFunction,
+      loop: track.loop || false,
+      yoyo: track.yoyo || false,
+      easingType: track.easing || "ease",
+      currentLoop: 0,
+      isReverse: false
+    };
+  }
+  /**
+   * Compiles an easing function from string specification to optimized function
+   * 
+   * @param easing - Easing type or cubic-bezier specification
+   * @returns Optimized easing function that maps [0,1] to [0,1]
+   */
+  static compileEasing(easing) {
+    if (typeof easing === "string" && easing.startsWith("cubic-bezier(")) {
+      return this.compileCubicBezier(easing);
+    }
+    switch (easing) {
+      case "linear":
+        return (t) => t;
+      case "ease":
+        return this.cubicBezier(0.25, 0.1, 0.25, 1);
+      case "ease-in":
+        return this.cubicBezier(0.42, 0, 1, 1);
+      case "ease-out":
+        return this.cubicBezier(0, 0, 0.58, 1);
+      case "ease-in-out":
+        return this.cubicBezier(0.42, 0, 0.58, 1);
+      // Sine easing functions
+      case "ease-in-sine":
+        return (t) => 1 - Math.cos(t * Math.PI / 2);
+      case "ease-out-sine":
+        return (t) => Math.sin(t * Math.PI / 2);
+      case "ease-in-out-sine":
+        return (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+      // Quadratic easing functions
+      case "ease-in-quad":
+        return (t) => t * t;
+      case "ease-out-quad":
+        return (t) => 1 - (1 - t) * (1 - t);
+      case "ease-in-out-quad":
+        return (t) => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+      // Cubic easing functions
+      case "ease-in-cubic":
+        return (t) => t * t * t;
+      case "ease-out-cubic":
+        return (t) => 1 - Math.pow(1 - t, 3);
+      case "ease-in-out-cubic":
+        return (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+      // Quartic easing functions
+      case "ease-in-quart":
+        return (t) => t * t * t * t;
+      case "ease-out-quart":
+        return (t) => 1 - Math.pow(1 - t, 4);
+      case "ease-in-out-quart":
+        return (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+      // Quintic easing functions
+      case "ease-in-quint":
+        return (t) => t * t * t * t * t;
+      case "ease-out-quint":
+        return (t) => 1 - Math.pow(1 - t, 5);
+      case "ease-in-out-quint":
+        return (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 - Math.pow(-2 * t + 2, 5) / 2;
+      // Exponential easing functions
+      case "ease-in-expo":
+        return (t) => t === 0 ? 0 : Math.pow(2, 10 * (t - 1));
+      case "ease-out-expo":
+        return (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+      case "ease-in-out-expo":
+        return (t) => {
+          if (t === 0) return 0;
+          if (t === 1) return 1;
+          return t < 0.5 ? Math.pow(2, 20 * t - 10) / 2 : (2 - Math.pow(2, -20 * t + 10)) / 2;
+        };
+      // Circular easing functions
+      case "ease-in-circ":
+        return (t) => 1 - Math.sqrt(1 - Math.pow(t, 2));
+      case "ease-out-circ":
+        return (t) => Math.sqrt(1 - Math.pow(t - 1, 2));
+      case "ease-in-out-circ":
+        return (t) => t < 0.5 ? (1 - Math.sqrt(1 - Math.pow(2 * t, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * t + 2, 2)) + 1) / 2;
+      // Back easing functions
+      case "ease-in-back":
+        return this.backEasing(1.70158, "in");
+      case "ease-out-back":
+        return this.backEasing(1.70158, "out");
+      case "ease-in-out-back":
+        return this.backEasing(1.70158, "in-out");
+      // Elastic easing functions
+      case "ease-in-elastic":
+        return this.elasticEasing(2 * Math.PI / 3, "in");
+      case "ease-out-elastic":
+        return this.elasticEasing(2 * Math.PI / 3, "out");
+      case "ease-in-out-elastic":
+        return this.elasticEasing(2 * Math.PI / 4.5, "in-out");
+      // Bounce easing functions
+      case "ease-in-bounce":
+        return (t) => 1 - this.bounceOut(1 - t);
+      case "ease-out-bounce":
+        return this.bounceOut;
+      case "ease-in-out-bounce":
+        return (t) => t < 0.5 ? (1 - this.bounceOut(1 - 2 * t)) / 2 : (1 + this.bounceOut(2 * t - 1)) / 2;
+      default:
+        return this.cubicBezier(0.25, 0.1, 0.25, 1);
+    }
+  }
+  /**
+   * Compiles an interpolation function for animating between two values
+   * 
+   * @param from - Starting value
+   * @param to - Ending value
+   * @param easingFunction - Easing function to apply
+   * @returns Optimized interpolation function
+   */
+  static compileInterpolation(from, to, easingFunction) {
+    const fromType = this.getValueType(from);
+    const toType = this.getValueType(to);
+    if (fromType !== toType) {
+      return (progress) => {
+        const easedProgress = easingFunction(Math.max(0, Math.min(1, progress)));
+        return easedProgress < 0.5 ? from : to;
+      };
+    }
+    switch (fromType) {
+      case "number":
+        return this.compileNumberInterpolation(from, to, easingFunction);
+      case "string":
+        return this.compileStringInterpolation(from, to, easingFunction);
+      case "boolean":
+        return this.compileBooleanInterpolation(from, to, easingFunction);
+      case "object":
+        return this.compileObjectInterpolation(
+          from,
+          to,
+          easingFunction
+        );
+      default:
+        return (progress) => {
+          const easedProgress = easingFunction(Math.max(0, Math.min(1, progress)));
+          return easedProgress < 0.5 ? from : to;
+        };
+    }
+  }
+  /**
+   * Creates a cubic-bezier easing function with the given control points
+   */
+  static cubicBezier(x1, y1, x2, y2) {
+    return (t) => {
+      const cx = 3 * x1;
+      const bx = 3 * (x2 - x1) - cx;
+      const ax = 1 - cx - bx;
+      const cy = 3 * y1;
+      const by = 3 * (y2 - y1) - cy;
+      const ay = 1 - cy - by;
+      let x = t;
+      for (let i = 0; i < 8; i++) {
+        const currentX = ((ax * x + bx) * x + cx) * x;
+        const currentSlope = (3 * ax * x + 2 * bx) * x + cx;
+        if (Math.abs(currentSlope) < 1e-6) break;
+        x = x - (currentX - t) / currentSlope;
+      }
+      return ((ay * x + by) * x + cy) * x;
+    };
+  }
+  /**
+   * Parses and compiles a cubic-bezier string specification
+   */
+  static compileCubicBezier(bezierString) {
+    const match = bezierString.match(/cubic-bezier\(([^)]+)\)/);
+    if (!match || !match[1]) {
+      return this.cubicBezier(0.25, 0.1, 0.25, 1);
+    }
+    const values = match[1].split(",").map((v) => parseFloat(v.trim()));
+    if (values.length !== 4 || values.some((v) => isNaN(v))) {
+      return this.cubicBezier(0.25, 0.1, 0.25, 1);
+    }
+    return this.cubicBezier(values[0], values[1], values[2], values[3]);
+  }
+  /**
+   * Creates a back easing function with overshoot
+   */
+  static backEasing(c, type) {
+    const c1 = c;
+    const c2 = c1 * 1.525;
+    const c3 = c1 + 1;
+    switch (type) {
+      case "in":
+        return (t) => c3 * t * t * t - c1 * t * t;
+      case "out":
+        return (t) => 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+      case "in-out":
+        return (t) => t < 0.5 ? Math.pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2) / 2 : (Math.pow(2 * t - 2, 2) * ((c2 + 1) * (t * 2 - 2) + c2) + 2) / 2;
+      default:
+        return (t) => t;
+    }
+  }
+  /**
+   * Creates an elastic easing function with oscillation
+   */
+  static elasticEasing(c, type) {
+    switch (type) {
+      case "in":
+        return (t) => {
+          if (t === 0) return 0;
+          if (t === 1) return 1;
+          return -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * c);
+        };
+      case "out":
+        return (t) => {
+          if (t === 0) return 0;
+          if (t === 1) return 1;
+          return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c) + 1;
+        };
+      case "in-out":
+        return (t) => {
+          if (t === 0) return 0;
+          if (t === 1) return 1;
+          return t < 0.5 ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * c)) / 2 : Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * c) / 2 + 1;
+        };
+      default:
+        return (t) => t;
+    }
+  }
+  /**
+   * Bounce easing out function
+   */
+  static bounceOut(t) {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) {
+      return n1 * t * t;
+    } else if (t < 2 / d1) {
+      return n1 * (t -= 1.5 / d1) * t + 0.75;
+    } else if (t < 2.5 / d1) {
+      return n1 * (t -= 2.25 / d1) * t + 0.9375;
+    } else {
+      return n1 * (t -= 2.625 / d1) * t + 0.984375;
+    }
+  }
+  /**
+   * Determines the type of an animation value
+   */
+  static getValueType(value) {
+    if (typeof value === "number") return "number";
+    if (typeof value === "string") return "string";
+    if (typeof value === "boolean") return "boolean";
+    if (typeof value === "object" && value !== null) return "object";
+    return "object";
+  }
+  /**
+   * Compiles number interpolation with optimized performance
+   */
+  static compileNumberInterpolation(from, to, easingFunction) {
+    const delta = to - from;
+    return (progress) => {
+      const easedProgress = easingFunction(Math.max(0, Math.min(1, progress)));
+      return from + delta * easedProgress;
+    };
+  }
+  /**
+   * Compiles string interpolation with CSS value support
+   */
+  static compileStringInterpolation(from, to, easingFunction) {
+    const fromMatch = from.match(/^([+-]?\d*\.?\d+)(.*)$/);
+    const toMatch = to.match(/^([+-]?\d*\.?\d+)(.*)$/);
+    if (fromMatch && toMatch && fromMatch[2] === toMatch[2]) {
+      const fromNum = parseFloat(fromMatch[1]);
+      const toNum = parseFloat(toMatch[1]);
+      const unit = fromMatch[2];
+      const delta = toNum - fromNum;
+      return (progress) => {
+        const easedProgress = easingFunction(Math.max(0, Math.min(1, progress)));
+        const interpolatedValue = fromNum + delta * easedProgress;
+        const roundedValue = Math.round(interpolatedValue * 1e6) / 1e6;
+        return `${roundedValue}${unit}`;
+      };
+    }
+    return (progress) => {
+      const easedProgress = easingFunction(Math.max(0, Math.min(1, progress)));
+      return easedProgress < 0.5 ? from : to;
+    };
+  }
+  /**
+   * Compiles boolean interpolation (discrete transition)
+   */
+  static compileBooleanInterpolation(from, to, easingFunction) {
+    return (progress) => {
+      const easedProgress = easingFunction(Math.max(0, Math.min(1, progress)));
+      return easedProgress < 0.5 ? from : to;
+    };
+  }
+  /**
+   * Compiles object interpolation for complex values
+   */
+  static compileObjectInterpolation(from, to, easingFunction) {
+    const propertyInterpolators = /* @__PURE__ */ new Map();
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(from), ...Object.keys(to)]);
+    for (const key of allKeys) {
+      const fromValue = from[key];
+      const toValue = to[key];
+      if (fromValue !== void 0 && toValue !== void 0) {
+        propertyInterpolators.set(key, this.compileInterpolation(fromValue, toValue, easingFunction));
+      } else if (fromValue !== void 0) {
+        propertyInterpolators.set(key, () => fromValue);
+      } else {
+        propertyInterpolators.set(key, (progress) => {
+          const easedProgress = easingFunction(Math.max(0, Math.min(1, progress)));
+          return easedProgress < 0.5 ? void 0 : toValue;
+        });
+      }
+    }
+    return (progress) => {
+      const result = {};
+      for (const [key, interpolator] of propertyInterpolators) {
+        const value = interpolator(progress);
+        if (value !== void 0) {
+          result[key] = value;
+        }
+      }
+      return result;
+    };
+  }
+};
+
+// src/parsing/SpecParser.ts
+var SUPPORTED_SCHEMA_VERSIONS = ["1.0.0", "1.1.0"];
+var QualityLevelSchema = z.enum(["low", "medium", "high", "ultra", "auto"]);
+var LayerTypeSchema = z.enum([
+  "gradient",
+  "image",
+  "textBlock",
+  "vignette",
+  "glowOrb",
+  "noiseOverlay",
+  "particles",
+  "starfield",
+  "dust",
+  "nebulaNoise",
+  "webgl-custom"
+]);
+var EasingTypeSchema = z.enum([
+  "linear",
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "ease-in-sine",
+  "ease-out-sine",
+  "ease-in-out-sine",
+  "ease-in-quad",
+  "ease-out-quad",
+  "ease-in-out-quad",
+  "ease-in-cubic",
+  "ease-out-cubic",
+  "ease-in-out-cubic",
+  "ease-in-quart",
+  "ease-out-quart",
+  "ease-in-out-quart",
+  "ease-in-quint",
+  "ease-out-quint",
+  "ease-in-out-quint",
+  "ease-in-expo",
+  "ease-out-expo",
+  "ease-in-out-expo",
+  "ease-in-circ",
+  "ease-out-circ",
+  "ease-in-out-circ",
+  "ease-in-back",
+  "ease-out-back",
+  "ease-in-out-back",
+  "ease-in-elastic",
+  "ease-out-elastic",
+  "ease-in-out-elastic",
+  "ease-in-bounce",
+  "ease-out-bounce",
+  "ease-in-out-bounce"
+]).or(z.string().regex(/^cubic-bezier\(\d*\.?\d+,\d*\.?\d+,\d*\.?\d+,\d*\.?\d+\)$/));
+var AudioTrackTypeSchema = z.enum(["voiceover", "ambience", "transition", "music", "sfx"]);
+var TransitionTypeSchema = z.enum(["fade", "slide", "zoom", "wipe", "dissolve", "blur"]);
+var AssetTypeSchema = z.enum(["image", "video", "audio", "font", "json", "binary"]);
+var TransformConfigSchema = z.object({
+  x: z.union([z.number(), z.string()]).optional(),
+  y: z.union([z.number(), z.string()]).optional(),
+  scale: z.number().optional(),
+  rotation: z.number().optional(),
+  origin: z.string().optional()
+}).optional();
+var LayerConfigSchema = z.object({
+  opacity: z.number().min(0).max(1).optional(),
+  visible: z.boolean().optional(),
+  transform: TransformConfigSchema
+}).catchall(z.any());
+var AnimationValueSchema = z.union([
+  z.number(),
+  z.string(),
+  z.boolean(),
+  z.record(z.union([z.number(), z.string(), z.boolean()]))
+]);
+var AnimationTrackSpecSchema = z.object({
+  property: z.string().min(1),
+  from: AnimationValueSchema,
+  to: AnimationValueSchema,
+  startMs: z.number().min(0),
+  endMs: z.number().min(0),
+  easing: EasingTypeSchema.optional().default("ease"),
+  loop: z.boolean().optional().default(false),
+  yoyo: z.boolean().optional().default(false)
+}).refine((data) => data.endMs > data.startMs, {
+  message: "endMs must be greater than startMs",
+  path: ["endMs"]
+});
+var AudioTrackSpecSchema = z.object({
+  id: z.string().min(1),
+  type: AudioTrackTypeSchema,
+  src: z.string().min(1),
+  startMs: z.number().min(0),
+  endMs: z.number().min(0).optional(),
+  volume: z.number().min(0).max(1).optional().default(1),
+  fadeIn: z.number().min(0).optional().default(0),
+  fadeOut: z.number().min(0).optional().default(0),
+  loop: z.boolean().optional().default(false)
+});
+var TransitionConfigSchema = z.object({
+  direction: z.enum(["up", "down", "left", "right", "in", "out"]).optional(),
+  blurAmount: z.number().min(0).optional()
+}).catchall(z.any()).optional();
+var TransitionSpecSchema = z.object({
+  type: TransitionTypeSchema,
+  duration: z.number().min(0),
+  easing: EasingTypeSchema.optional().default("ease"),
+  config: TransitionConfigSchema
+});
+var AssetMetadataSchema = z.object({
+  size: z.number().min(0).optional(),
+  mimeType: z.string().optional(),
+  cacheDuration: z.number().min(0).optional(),
+  dimensions: z.object({
+    width: z.number().min(1),
+    height: z.number().min(1)
+  }).optional(),
+  duration: z.number().min(0).optional()
+}).optional();
+var AssetDefinitionSchema = z.object({
+  id: z.string().min(1),
+  type: AssetTypeSchema,
+  src: z.string().min(1),
+  preload: z.boolean().optional().default(true),
+  fallback: z.string().optional(),
+  metadata: AssetMetadataSchema
+});
+var LayerSpecSchema = z.object({
+  id: z.string().min(1),
+  type: LayerTypeSchema,
+  zIndex: z.number(),
+  config: LayerConfigSchema,
+  animations: z.array(AnimationTrackSpecSchema).optional().default([])
+});
+var CinematicSceneSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  duration: z.number().min(0),
+  layers: z.array(LayerSpecSchema).min(1),
+  audio: z.array(AudioTrackSpecSchema).optional().default([])
+});
+var CinematicEventSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  scenes: z.array(z.string().min(1)).min(1),
+  transitions: z.array(TransitionSpecSchema).optional().default([])
+});
+var EngineConfigSchema = z.object({
+  targetFps: z.number().min(1).max(240).optional().default(60),
+  quality: QualityLevelSchema.optional().default("auto"),
+  debug: z.boolean().optional().default(false),
+  autoplay: z.boolean().optional().default(false)
+});
+var CinematicSpecSchema = z.object({
+  schemaVersion: z.string().min(1),
+  engine: EngineConfigSchema,
+  events: z.array(CinematicEventSchema).min(1),
+  scenes: z.array(CinematicSceneSchema).min(1),
+  assets: z.array(AssetDefinitionSchema).optional().default([])
+}).refine((data) => {
+  const sceneIds = new Set(data.scenes.map((scene) => scene.id));
+  const referencedSceneIds = new Set(data.events.flatMap((event) => event.scenes));
+  for (const sceneId of referencedSceneIds) {
+    if (!sceneIds.has(sceneId)) {
+      return false;
+    }
+  }
+  return true;
+}, {
+  message: "All scene IDs referenced in events must exist in the scenes array",
+  path: ["events"]
+}).refine((data) => {
+  var _a;
+  const eventIds = data.events.map((e) => e.id);
+  const sceneIds = data.scenes.map((s) => s.id);
+  const assetIds = ((_a = data.assets) == null ? void 0 : _a.map((a) => a.id)) || [];
+  return new Set(eventIds).size === eventIds.length && new Set(sceneIds).size === sceneIds.length && new Set(assetIds).size === assetIds.length;
+}, {
+  message: "All IDs must be unique within their respective collections",
+  path: ["events", "scenes", "assets"]
+});
+var SpecParser = class {
+  /**
+   * Validates and parses a raw JSON specification into a validated CinematicSpec
+   * 
+   * @param spec - Raw JSON specification to validate
+   * @returns Validated CinematicSpec with applied defaults
+   * @throws ZodError with descriptive validation messages
+   */
+  static validate(spec) {
+    try {
+      if (typeof spec !== "object" || spec === null) {
+        throw new Error("Specification must be a valid object");
+      }
+      const rawSpec = spec;
+      const schemaVersion = rawSpec["schemaVersion"];
+      if (!schemaVersion || typeof schemaVersion !== "string") {
+        throw new Error("Missing or invalid schemaVersion. Current supported versions: " + SUPPORTED_SCHEMA_VERSIONS.join(", "));
+      }
+      if (!SUPPORTED_SCHEMA_VERSIONS.includes(schemaVersion)) {
+        throw new Error(`Unsupported schema version: ${schemaVersion}. Supported versions: ${SUPPORTED_SCHEMA_VERSIONS.join(", ")}`);
+      }
+      const validatedSpec = this.validateByVersion(spec, schemaVersion);
+      return validatedSpec;
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(this.formatZodError(error));
+      }
+      throw error;
+    }
+  }
+  /**
+   * Compiles a validated CinematicSpec into an optimized CompiledSpec
+   * 
+   * @param spec - Validated CinematicSpec to compile
+   * @returns CompiledSpec with precompiled animations and optimized runtime structures
+   */
+  static parse(spec) {
+    const context = {
+      schemaVersion: spec.schemaVersion,
+      assetPromises: /* @__PURE__ */ new Map(),
+      layerTypes: new Set(spec.scenes.flatMap((s) => s.layers.map((l) => l.type))),
+      diagnostics: [],
+      optimizations: {
+        precompileAnimations: true,
+        optimizeAssetLoading: true,
+        enableObjectPooling: true,
+        minimizeDOMUpdates: true,
+        useWebWorkers: false
+        // Disabled for now
+      }
+    };
+    try {
+      const compiledAssets = this.compileAssets(spec.assets || [], context);
+      const compiledScenes = this.compileScenes(spec.scenes, context);
+      const compiledEvents = this.compileEvents(spec.events, compiledScenes, context);
+      const totalDuration = Math.max(...Array.from(compiledEvents.values()).map((event) => event.startTime + event.duration));
+      const compiledSpec = {
+        events: compiledEvents,
+        scenes: compiledScenes,
+        assets: compiledAssets,
+        globalConfig: spec.engine,
+        schemaVersion: spec.schemaVersion,
+        totalDuration,
+        compiledAt: Date.now()
+      };
+      if (context.diagnostics.length > 0) {
+        console.warn("Compilation completed with warnings:", context.diagnostics);
+      }
+      return compiledSpec;
+    } catch (error) {
+      context.diagnostics.push({
+        level: "error",
+        message: error instanceof Error ? error.message : "Unknown compilation error",
+        code: "COMPILATION_ERROR"
+      });
+      throw new Error(`Compilation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Validates specification based on schema version
+   */
+  static validateByVersion(spec, version) {
+    switch (version) {
+      case "1.0.0":
+      case "1.1.0":
+        return CinematicSpecSchema.parse(spec);
+      default:
+        throw new Error(`Unsupported schema version: ${version}`);
+    }
+  }
+  /**
+   * Compiles asset definitions into runtime assets
+   */
+  static compileAssets(assets, _context) {
+    var _a, _b, _c, _d, _e;
+    const compiledAssets = /* @__PURE__ */ new Map();
+    for (const assetDef of assets) {
+      const asset = {
+        id: assetDef.id,
+        type: assetDef.type,
+        src: assetDef.src,
+        data: null,
+        loaded: false,
+        error: null,
+        fallback: assetDef.fallback,
+        metadata: {
+          size: ((_a = assetDef.metadata) == null ? void 0 : _a.size) || 0,
+          mimeType: ((_b = assetDef.metadata) == null ? void 0 : _b.mimeType) || "",
+          cacheDuration: ((_c = assetDef.metadata) == null ? void 0 : _c.cacheDuration) || 36e5,
+          // 1 hour default
+          dimensions: (_d = assetDef.metadata) == null ? void 0 : _d.dimensions,
+          duration: (_e = assetDef.metadata) == null ? void 0 : _e.duration,
+          quality: 1,
+          streamable: false,
+          priority: "normal"
+        },
+        progress: 0
+      };
+      compiledAssets.set(assetDef.id, asset);
+    }
+    return compiledAssets;
+  }
+  /**
+   * Compiles scene definitions into runtime scenes
+   */
+  static compileScenes(scenes, context) {
+    const compiledScenes = /* @__PURE__ */ new Map();
+    let currentStartTime = 0;
+    for (const scene of scenes) {
+      const compiledLayers = this.compileLayers(scene.layers, context);
+      const compiledAudioTracks = this.compileAudioTracks(scene.audio || [], context);
+      const compiledScene = {
+        id: scene.id,
+        name: scene.name,
+        duration: scene.duration,
+        layers: compiledLayers,
+        audioTracks: compiledAudioTracks,
+        startTime: currentStartTime,
+        endTime: currentStartTime + scene.duration
+      };
+      compiledScenes.set(scene.id, compiledScene);
+      currentStartTime += scene.duration;
+    }
+    return compiledScenes;
+  }
+  /**
+   * Compiles layer specifications into runtime layers
+   */
+  static compileLayers(layers, context) {
+    return layers.sort((a, b) => a.zIndex - b.zIndex).map((layer) => {
+      const compiledAnimations = this.compileAnimationTracks(layer.animations || [], context);
+      const layerInstance = {
+        id: layer.id,
+        type: layer.type,
+        zIndex: layer.zIndex,
+        mount: () => {
+        },
+        update: () => {
+        },
+        destroy: () => {
+        }
+      };
+      const compiledLayer = {
+        id: layer.id,
+        type: layer.type,
+        zIndex: layer.zIndex,
+        instance: layerInstance,
+        animations: compiledAnimations,
+        initialConfig: { ...layer.config },
+        active: true
+      };
+      return compiledLayer;
+    });
+  }
+  /**
+   * Compiles animation tracks into optimized runtime animations
+   */
+  static compileAnimationTracks(tracks, _context) {
+    return tracks.map((track) => AnimationCompiler.compileTrack(track));
+  }
+  /**
+   * Compiles audio tracks into runtime audio objects
+   */
+  static compileAudioTracks(tracks, _context) {
+    return tracks.map((track) => {
+      const asset = {
+        id: track.id,
+        type: "audio",
+        src: track.src,
+        data: null,
+        loaded: false,
+        error: null,
+        metadata: {
+          size: 0,
+          mimeType: "audio/mpeg",
+          cacheDuration: 36e5,
+          priority: "normal"
+        },
+        progress: 0
+      };
+      const compiledTrack = {
+        id: track.id,
+        type: track.type,
+        asset,
+        startMs: track.startMs,
+        endMs: track.endMs || 0,
+        // Will be set when audio loads
+        volume: track.volume || 1,
+        fadeIn: track.fadeIn || 0,
+        fadeOut: track.fadeOut || 0,
+        loop: track.loop || false
+      };
+      return compiledTrack;
+    });
+  }
+  /**
+   * Compiles event definitions into runtime events
+   */
+  static compileEvents(events, scenes, context) {
+    const compiledEvents = /* @__PURE__ */ new Map();
+    let currentStartTime = 0;
+    for (const event of events) {
+      const eventScenes = event.scenes.map((sceneId) => {
+        const scene = scenes.get(sceneId);
+        if (!scene) {
+          throw new Error(`Scene with ID "${sceneId}" not found for event "${event.id}"`);
+        }
+        return scene;
+      });
+      const compiledTransitions = this.compileTransitions(event.transitions || [], context);
+      const eventDuration = eventScenes.reduce((total, scene) => total + scene.duration, 0);
+      const compiledEvent = {
+        id: event.id,
+        name: event.name,
+        scenes: eventScenes,
+        transitions: compiledTransitions,
+        duration: eventDuration,
+        startTime: currentStartTime
+      };
+      compiledEvents.set(event.id, compiledEvent);
+      currentStartTime += eventDuration;
+    }
+    return compiledEvents;
+  }
+  /**
+   * Compiles transition specifications into runtime transitions
+   */
+  static compileTransitions(transitions, _context) {
+    return transitions.map((transition) => {
+      const easingFunction = AnimationCompiler.compileEasing(transition.easing || "ease");
+      const executeFunction = (progress, _fromElement, _toElement) => {
+      };
+      const compiledTransition = {
+        type: transition.type,
+        duration: transition.duration,
+        easingFunction,
+        config: transition.config || {},
+        execute: executeFunction
+      };
+      return compiledTransition;
+    });
+  }
+  /**
+   * Formats Zod validation errors into human-readable messages
+   */
+  static formatZodError(error) {
+    const messages = error.errors.map((err) => {
+      const path = err.path.length > 0 ? `at ${err.path.join(".")}` : "at root";
+      return `${path}: ${err.message}`;
+    });
+    return `Specification validation failed:
+${messages.join("\n")}`;
+  }
+};
+
+// src/cli/index.ts
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    showHelp();
+    process.exit(0);
+  }
+  try {
+    const options = parseArgs(args);
+    await executeCommand(options);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+function parseArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "validate":
+      case "preview":
+        if (options.command) {
+          throw new Error("Multiple commands specified. Use only one command.");
+        }
+        options.command = arg;
+        break;
+      case "-f":
+      case "--file":
+        if (i + 1 >= args.length) {
+          throw new Error("--file requires a file path");
+        }
+        const fileArg = args[i + 1];
+        if (!fileArg) {
+          throw new Error("--file requires a file path");
+        }
+        options.file = fileArg;
+        i++;
+        break;
+      case "-v":
+      case "--verbose":
+        options.verbose = true;
+        break;
+      case "-o":
+      case "--output":
+        if (i + 1 >= args.length) {
+          throw new Error("--output requires a file path");
+        }
+        const outputArg = args[i + 1];
+        if (!outputArg) {
+          throw new Error("--output requires a file path");
+        }
+        options.output = outputArg;
+        i++;
+        break;
+      case "-h":
+      case "--help":
+        showHelp();
+        process.exit(0);
+        break;
+      default:
+        if (arg && !options.command && !arg.startsWith("-")) {
+          throw new Error(`Unknown command: ${arg}. Use 'validate' or 'preview'.`);
+        } else if (arg && !options.file && !arg.startsWith("-")) {
+          options.file = arg;
+        } else if (arg) {
+          throw new Error(`Unknown option: ${arg}`);
+        }
+    }
+  }
+  if (!options.command) {
+    throw new Error('No command specified. Use "validate" or "preview".');
+  }
+  if (!options.file) {
+    throw new Error("No file specified. Use --file or provide file path.");
+  }
+  return options;
+}
+async function executeCommand(options) {
+  switch (options.command) {
+    case "validate":
+      await validateCommand(options);
+      break;
+    case "preview":
+      await previewCommand(options);
+      break;
+    default:
+      throw new Error(`Unknown command: ${options.command}`);
+  }
+}
+async function validateCommand(options) {
+  var _a, _b;
+  const filePath = resolve(options.file);
+  if (!existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  if (options.verbose) {
+    console.log(`Validating specification: ${filePath}`);
+  }
+  try {
+    const fileContent = readFileSync(filePath, "utf-8");
+    let jsonSpec;
+    try {
+      jsonSpec = JSON.parse(fileContent);
+    } catch (parseError) {
+      throw new Error(`Invalid JSON format: ${parseError instanceof Error ? parseError.message : "Unknown JSON error"}`);
+    }
+    const validatedSpec = SpecParser.validate(jsonSpec);
+    const compiledSpec = SpecParser.parse(validatedSpec);
+    console.log("\u2705 Specification is valid!");
+    if (options.verbose) {
+      console.log("\nSpecification Details:");
+      console.log(`  Schema Version: ${validatedSpec.schemaVersion}`);
+      console.log(`  Events: ${validatedSpec.events.length}`);
+      console.log(`  Scenes: ${validatedSpec.scenes.length}`);
+      console.log(`  Assets: ${((_a = validatedSpec.assets) == null ? void 0 : _a.length) || 0}`);
+      console.log(`  Total Duration: ${compiledSpec.totalDuration}ms`);
+      console.log(`  Target FPS: ${validatedSpec.engine.targetFps}`);
+      console.log(`  Quality: ${validatedSpec.engine.quality}`);
+      const layerTypes = new Set(validatedSpec.scenes.flatMap((s) => s.layers.map((l) => l.type)));
+      console.log(`  Layer Types: ${Array.from(layerTypes).join(", ")}`);
+      const audioTracks = validatedSpec.scenes.flatMap((s) => s.audio || []);
+      if (audioTracks.length > 0) {
+        console.log(`  Audio Tracks: ${audioTracks.length}`);
+        const audioTypes = new Set(audioTracks.map((a) => a.type));
+        console.log(`  Audio Types: ${Array.from(audioTypes).join(", ")}`);
+      }
+    }
+    if (options.output) {
+      const report = {
+        valid: true,
+        file: filePath,
+        validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        spec: {
+          schemaVersion: validatedSpec.schemaVersion,
+          events: validatedSpec.events.length,
+          scenes: validatedSpec.scenes.length,
+          assets: ((_b = validatedSpec.assets) == null ? void 0 : _b.length) || 0,
+          totalDuration: compiledSpec.totalDuration,
+          targetFps: validatedSpec.engine.targetFps,
+          quality: validatedSpec.engine.quality
+        }
+      };
+      const { writeFileSync } = await import('fs');
+      writeFileSync(options.output, JSON.stringify(report, null, 2));
+      console.log(`\u{1F4C4} Validation report saved to: ${options.output}`);
+    }
+  } catch (error) {
+    console.error("\u274C Specification validation failed:");
+    console.error(error instanceof Error ? error.message : "Unknown validation error");
+    if (options.output) {
+      const errorReport = {
+        valid: false,
+        file: filePath,
+        validatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        error: error instanceof Error ? error.message : "Unknown validation error"
+      };
+      const { writeFileSync } = await import('fs');
+      writeFileSync(options.output, JSON.stringify(errorReport, null, 2));
+      console.log(`\u{1F4C4} Error report saved to: ${options.output}`);
+    }
+    process.exit(1);
+  }
+}
+async function previewCommand(options) {
+  const filePath = resolve(options.file);
+  if (!existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  if (options.verbose) {
+    console.log(`Generating preview for: ${filePath}`);
+  }
+  try {
+    const fileContent = readFileSync(filePath, "utf-8");
+    let jsonSpec;
+    try {
+      jsonSpec = JSON.parse(fileContent);
+    } catch (parseError) {
+      throw new Error(`Invalid JSON format: ${parseError instanceof Error ? parseError.message : "Unknown JSON error"}`);
+    }
+    const validatedSpec = SpecParser.validate(jsonSpec);
+    const compiledSpec = SpecParser.parse(validatedSpec);
+    const previewHtml = generatePreviewHtml(validatedSpec, compiledSpec, filePath);
+    if (options.output) {
+      const { writeFileSync } = await import('fs');
+      writeFileSync(options.output, previewHtml);
+      console.log(`\u{1F3AC} Preview saved to: ${options.output}`);
+      console.log(`   Open in browser to view the cinematic experience.`);
+    } else {
+      const { tmpdir } = await import('os');
+      const { join } = await import('path');
+      const tempFile = join(tmpdir(), `cinematic-preview-${Date.now()}.html`);
+      const { writeFileSync } = await import('fs');
+      writeFileSync(tempFile, previewHtml);
+      console.log(`\u{1F3AC} Preview generated: ${tempFile}`);
+      console.log(`   Open this file in your browser to view the cinematic experience.`);
+      try {
+        const { exec } = await import('child_process');
+        const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        exec(`${command} "${tempFile}"`);
+        console.log(`   Opening in default browser...`);
+      } catch {
+      }
+    }
+  } catch (error) {
+    console.error("\u274C Preview generation failed:");
+    console.error(error instanceof Error ? error.message : "Unknown preview error");
+    process.exit(1);
+  }
+}
+function generatePreviewHtml(spec, compiledSpec, filePath) {
+  var _a, _b;
+  const specJson = JSON.stringify(spec, null, 2);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Cinematic Preview - ${((_a = spec.events[0]) == null ? void 0 : _a.name) || "Untitled"}</title>
+    <style>
+        body {
+            margin: 0;
+            padding: 20px;
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: #1a1a1a;
+            color: #ffffff;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 30px;
+        }
+        .preview-area {
+            background: #000;
+            border-radius: 8px;
+            margin-bottom: 30px;
+            position: relative;
+            aspect-ratio: 16/9;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            border: 2px solid #333;
+        }
+        .placeholder {
+            text-align: center;
+            color: #666;
+        }
+        .controls {
+            display: flex;
+            justify-content: center;
+            gap: 10px;
+            margin-bottom: 30px;
+        }
+        .btn {
+            padding: 10px 20px;
+            background: #007acc;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 14px;
+        }
+        .btn:hover {
+            background: #005a9e;
+        }
+        .btn:disabled {
+            background: #333;
+            cursor: not-allowed;
+        }
+        .info-panel {
+            background: #2a2a2a;
+            border-radius: 8px;
+            padding: 20px;
+            margin-bottom: 20px;
+        }
+        .info-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+        }
+        .info-item {
+            background: #333;
+            padding: 15px;
+            border-radius: 4px;
+        }
+        .info-label {
+            font-size: 12px;
+            color: #999;
+            text-transform: uppercase;
+            margin-bottom: 5px;
+        }
+        .info-value {
+            font-size: 16px;
+            font-weight: 600;
+        }
+        .spec-details {
+            background: #2a2a2a;
+            border-radius: 8px;
+            padding: 20px;
+        }
+        .spec-json {
+            background: #1a1a1a;
+            border-radius: 4px;
+            padding: 15px;
+            overflow-x: auto;
+            font-family: 'Monaco', 'Menlo', monospace;
+            font-size: 12px;
+            line-height: 1.4;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+        .warning {
+            background: #ff6b35;
+            color: white;
+            padding: 15px;
+            border-radius: 4px;
+            margin-bottom: 20px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>\u{1F3AC} Cinematic Preview</h1>
+            <p>Specification: <code>${filePath}</code></p>
+        </div>
+        
+        <div class="warning">
+            <strong>\u26A0\uFE0F Preview Mode:</strong> This is a static preview of your specification. 
+            For full interactive playback, integrate the cinematic-renderer2d library into your application.
+        </div>
+        
+        <div class="preview-area">
+            <div class="placeholder">
+                <h2>\u{1F3AD} Cinematic Renderer Preview</h2>
+                <p>Interactive preview would appear here</p>
+                <p>Total Duration: ${compiledSpec.totalDuration}ms</p>
+            </div>
+        </div>
+        
+        <div class="controls">
+            <button class="btn" disabled>\u25B6\uFE0F Play</button>
+            <button class="btn" disabled>\u23F8\uFE0F Pause</button>
+            <button class="btn" disabled>\u23F9\uFE0F Stop</button>
+            <button class="btn" disabled>\u23EE\uFE0F Previous</button>
+            <button class="btn" disabled>\u23ED\uFE0F Next</button>
+        </div>
+        
+        <div class="info-panel">
+            <h3>Specification Overview</h3>
+            <div class="info-grid">
+                <div class="info-item">
+                    <div class="info-label">Schema Version</div>
+                    <div class="info-value">${spec.schemaVersion}</div>
+                </div>
+                <div class="info-item">
+                    <div class="info-label">Events</div>
+                    <div class="info-value">${spec.events.length}</div>
+                </div>
+                <div class="info-item">
+                    <div class="info-label">Scenes</div>
+                    <div class="info-value">${spec.scenes.length}</div>
+                </div>
+                <div class="info-item">
+                    <div class="info-label">Assets</div>
+                    <div class="info-value">${((_b = spec.assets) == null ? void 0 : _b.length) || 0}</div>
+                </div>
+                <div class="info-item">
+                    <div class="info-label">Target FPS</div>
+                    <div class="info-value">${spec.engine.targetFps}</div>
+                </div>
+                <div class="info-item">
+                    <div class="info-label">Quality</div>
+                    <div class="info-value">${spec.engine.quality}</div>
+                </div>
+                <div class="info-item">
+                    <div class="info-label">Total Duration</div>
+                    <div class="info-value">${Math.round(compiledSpec.totalDuration / 1e3)}s</div>
+                </div>
+                <div class="info-item">
+                    <div class="info-label">Layer Types</div>
+                    <div class="info-value">${Array.from(new Set(spec.scenes.flatMap((s) => s.layers.map((l) => l.type)))).join(", ")}</div>
+                </div>
+            </div>
+        </div>
+        
+        <div class="spec-details">
+            <h3>Specification Details</h3>
+            <pre class="spec-json">${specJson}</pre>
+        </div>
+    </div>
+</body>
+</html>`;
+}
+function showHelp() {
+  console.log(`
+\u{1F3AC} Cinematic Renderer 2D CLI
+
+USAGE:
+  cinematic-cli <command> [options]
+
+COMMANDS:
+  validate    Validate a JSON specification file
+  preview     Generate an HTML preview of the specification
+
+OPTIONS:
+  -f, --file <path>     Specification file to process (required)
+  -v, --verbose         Show detailed output
+  -o, --output <path>   Output file path (optional)
+  -h, --help           Show this help message
+
+EXAMPLES:
+  # Validate a specification
+  cinematic-cli validate --file my-spec.json
+
+  # Validate with verbose output
+  cinematic-cli validate --file my-spec.json --verbose
+
+  # Generate preview
+  cinematic-cli preview --file my-spec.json
+
+  # Save preview to specific file
+  cinematic-cli preview --file my-spec.json --output preview.html
+
+  # Save validation report
+  cinematic-cli validate --file my-spec.json --output report.json
+`);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
+
+export { main as runCLI };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map