@a-company/atelier 0.1.0

package/dist/chunk-LL2EJ6YE.js

@@ -0,0 +1,1465 @@
+// src/commands/validate.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+
+// ../schema/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+import { z as z10 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
+import { z as z13 } from "zod";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+var PixelSchema = z.number();
+var PercentageSchema = z.string().regex(/^-?\d+(\.\d+)?%$/, {
+  message: 'Percentage must be a number followed by %, e.g. "50%"'
+});
+var UnitValueSchema = z.union([PixelSchema, PercentageSchema]);
+var FrameSchema = z2.object({
+  x: UnitValueSchema,
+  y: UnitValueSchema
+});
+var BoundsSchema = z2.object({
+  width: UnitValueSchema,
+  height: UnitValueSchema
+});
+var AnchorPointSchema = z2.object({
+  x: z2.number().min(0).max(1),
+  y: z2.number().min(0).max(1)
+});
+var RGBAColorSchema = z3.object({
+  r: z3.number().min(0).max(255),
+  g: z3.number().min(0).max(255),
+  b: z3.number().min(0).max(255),
+  a: z3.number().min(0).max(1)
+});
+var HSLAColorSchema = z3.object({
+  h: z3.number().min(0).max(360),
+  s: z3.number().min(0).max(100),
+  l: z3.number().min(0).max(100),
+  a: z3.number().min(0).max(1)
+});
+var HexColorSchema = z3.string().regex(/^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+  message: "Color must be a hex string: #RGB, #RGBA, #RRGGBB, or #RRGGBBAA"
+});
+var ColorSchema = z3.union([RGBAColorSchema, HSLAColorSchema, HexColorSchema]);
+var PathPointSchema = z4.object({
+  x: z4.number(),
+  y: z4.number(),
+  in: z4.object({ x: z4.number(), y: z4.number() }).optional(),
+  out: z4.object({ x: z4.number(), y: z4.number() }).optional()
+});
+var RectShapeSchema = z4.object({
+  type: z4.literal("rect"),
+  cornerRadius: z4.union([
+    z4.number().min(0),
+    z4.tuple([z4.number().min(0), z4.number().min(0), z4.number().min(0), z4.number().min(0)])
+  ]).optional()
+});
+var EllipseShapeSchema = z4.object({
+  type: z4.literal("ellipse")
+});
+var PathShapeSchema = z4.object({
+  type: z4.literal("path"),
+  points: z4.array(PathPointSchema).min(2, "Path must have at least 2 points"),
+  closed: z4.boolean().optional()
+});
+var ShapeSchema = z4.discriminatedUnion("type", [
+  RectShapeSchema,
+  EllipseShapeSchema,
+  PathShapeSchema
+]);
+var GradientStopSchema = z4.object({
+  offset: z4.number().min(0).max(1),
+  color: ColorSchema
+});
+var SolidFillSchema = z4.object({
+  type: z4.literal("solid"),
+  color: ColorSchema
+});
+var LinearGradientFillSchema = z4.object({
+  type: z4.literal("linear-gradient"),
+  angle: z4.number(),
+  stops: z4.array(GradientStopSchema).min(2, "Gradient needs at least 2 stops")
+});
+var RadialGradientFillSchema = z4.object({
+  type: z4.literal("radial-gradient"),
+  center: z4.object({ x: UnitValueSchema, y: UnitValueSchema }),
+  radius: UnitValueSchema,
+  stops: z4.array(GradientStopSchema).min(2, "Gradient needs at least 2 stops")
+});
+var FillSchema = z4.discriminatedUnion("type", [
+  SolidFillSchema,
+  LinearGradientFillSchema,
+  RadialGradientFillSchema
+]);
+var StrokeSchema = z4.object({
+  color: ColorSchema,
+  width: z4.number().min(0),
+  dash: z4.array(z4.number().min(0)).optional(),
+  lineCap: z4.enum(["butt", "round", "square"]).optional(),
+  lineJoin: z4.enum(["miter", "round", "bevel"]).optional(),
+  strokeStart: z4.number().min(0).max(1).optional(),
+  strokeEnd: z4.number().min(0).max(1).optional()
+});
+var TextStyleSchema = z4.object({
+  fontFamily: z4.string().min(1, "fontFamily is required"),
+  fontSize: z4.number().positive("fontSize must be positive"),
+  fontWeight: z4.union([z4.number(), z4.enum(["normal", "bold"])]).optional(),
+  fontStyle: z4.enum(["normal", "italic"]).optional(),
+  textAlign: z4.enum(["left", "center", "right"]).optional(),
+  lineHeight: z4.number().positive().optional(),
+  letterSpacing: z4.number().optional(),
+  color: ColorSchema
+});
+var LinearEasingSchema = z5.object({ type: z5.literal("linear") });
+var CubicBezierEasingSchema = z5.object({
+  type: z5.literal("cubic-bezier"),
+  x1: z5.number().min(0).max(1),
+  y1: z5.number(),
+  x2: z5.number().min(0).max(1),
+  y2: z5.number()
+});
+var SpringEasingSchema = z5.object({
+  type: z5.literal("spring"),
+  mass: z5.number().positive().optional(),
+  stiffness: z5.number().positive().optional(),
+  damping: z5.number().positive().optional(),
+  velocity: z5.number().optional()
+});
+var StepEasingSchema = z5.object({
+  type: z5.literal("step"),
+  steps: z5.number().int().positive(),
+  position: z5.enum(["start", "end"]).optional()
+});
+var EasingPresetSchema = z5.enum(["ease-in", "ease-out", "ease-in-out"]);
+var EasingSchema = z5.union([
+  LinearEasingSchema,
+  CubicBezierEasingSchema,
+  SpringEasingSchema,
+  StepEasingSchema,
+  EasingPresetSchema
+]);
+var ShadowSchema = z6.object({
+  color: ColorSchema,
+  blur: z6.number().min(0),
+  offsetX: z6.number().optional(),
+  offsetY: z6.number().optional()
+});
+var ShapeVisualSchema = z7.object({
+  type: z7.literal("shape"),
+  shape: ShapeSchema,
+  fill: FillSchema.optional(),
+  stroke: StrokeSchema.optional()
+});
+var TextVisualSchema = z7.object({
+  type: z7.literal("text"),
+  content: z7.string(),
+  style: TextStyleSchema
+});
+var ImageVisualSchema = z7.object({
+  type: z7.literal("image"),
+  assetId: z7.string().min(1, "assetId is required"),
+  src: z7.string().optional()
+});
+var GroupVisualSchema = z7.object({
+  type: z7.literal("group")
+});
+var RefVisualSchema = z7.object({
+  type: z7.literal("ref"),
+  src: z7.string().min(1, "src is required")
+});
+var VisualSchema = z7.discriminatedUnion("type", [
+  ShapeVisualSchema,
+  TextVisualSchema,
+  ImageVisualSchema,
+  GroupVisualSchema,
+  RefVisualSchema
+]);
+var LayerSchema = z7.object({
+  id: z7.string().min(1, "Layer id is required"),
+  description: z7.string().optional(),
+  tags: z7.array(z7.string()).optional(),
+  visual: VisualSchema,
+  frame: FrameSchema,
+  bounds: BoundsSchema,
+  anchorPoint: AnchorPointSchema.optional(),
+  parentId: z7.string().optional(),
+  opacity: z7.number().min(0).max(1).optional(),
+  rotation: z7.number().optional(),
+  scale: z7.object({ x: z7.number(), y: z7.number() }).optional(),
+  visible: z7.boolean().optional(),
+  shadow: ShadowSchema.optional()
+});
+var AnimatablePropertySchema = z8.enum([
+  "frame.x",
+  "frame.y",
+  "bounds.width",
+  "bounds.height",
+  "opacity",
+  "rotation",
+  "scale.x",
+  "scale.y",
+  "anchorPoint.x",
+  "anchorPoint.y",
+  "visual.shape.cornerRadius",
+  "visual.fill.color",
+  "visual.stroke.color",
+  "visual.stroke.width",
+  "visual.stroke.start",
+  "visual.stroke.end",
+  "visual.style.fontSize",
+  "visual.style.color",
+  "shadow.color",
+  "shadow.blur",
+  "shadow.offsetX",
+  "shadow.offsetY"
+]);
+var FrameRangeSchema = z8.tuple([
+  z8.number().int().min(0, "Frame start must be >= 0"),
+  z8.number().int().min(0, "Frame end must be >= 0")
+]).refine(([start, end]) => end >= start, {
+  message: "Frame range end must be >= start"
+});
+var DeltaSchema = z8.object({
+  id: z8.string().optional(),
+  name: z8.string().optional(),
+  layer: z8.string().min(1, "Delta must reference a layer id"),
+  property: AnimatablePropertySchema,
+  range: FrameRangeSchema,
+  from: z8.unknown(),
+  to: z8.unknown(),
+  easing: EasingSchema.optional(),
+  description: z8.string().optional(),
+  tags: z8.array(z8.string()).optional()
+});
+var StateSchema = z9.object({
+  description: z9.string().optional(),
+  tags: z9.array(z9.string()).optional(),
+  duration: z9.number().int().positive("State duration must be a positive integer (frames)"),
+  deltas: z9.array(DeltaSchema)
+});
+var PresetDeltaSchema = z10.object({
+  property: AnimatablePropertySchema,
+  offset: z10.tuple([z10.number().int().min(0), z10.number().int().min(0)]).optional(),
+  from: z10.unknown(),
+  to: z10.unknown(),
+  easing: EasingSchema.optional()
+});
+var PresetSchema = z10.object({
+  description: z10.string().optional(),
+  tags: z10.array(z10.string()).optional(),
+  deltas: z10.array(PresetDeltaSchema).min(1, "Preset must have at least one delta")
+});
+var VariableTypeSchema = z11.enum(["string", "number", "color", "asset", "boolean"]);
+var VariableSchema = z11.object({
+  type: VariableTypeSchema,
+  default: z11.unknown().optional(),
+  description: z11.string().optional()
+});
+var AssetTypeSchema = z12.enum(["image", "svg", "font", "animation"]);
+var AssetSchema = z12.object({
+  type: AssetTypeSchema,
+  src: z12.string().min(1, "Asset src is required"),
+  description: z12.string().optional()
+});
+var CanvasSchema = z13.object({
+  width: z13.number().int().positive("Canvas width must be a positive integer"),
+  height: z13.number().int().positive("Canvas height must be a positive integer"),
+  fps: z13.number().int().positive("FPS must be a positive integer"),
+  background: z13.string().optional()
+});
+var AtelierDocumentSchema = z13.object({
+  version: z13.string().min(1, "Version is required"),
+  name: z13.string().min(1, "Animation name is required"),
+  description: z13.string().optional(),
+  tags: z13.array(z13.string()).optional(),
+  canvas: CanvasSchema,
+  variables: z13.record(z13.string(), VariableSchema).optional(),
+  assets: z13.record(z13.string(), AssetSchema).optional(),
+  presets: z13.record(z13.string(), PresetSchema).optional(),
+  layers: z13.array(LayerSchema),
+  states: z13.record(z13.string(), StateSchema)
+});
+function formatErrors(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join(".") || "(root)",
+    message: issue.message
+  }));
+}
+function validateDocument(input) {
+  const result = AtelierDocumentSchema.safeParse(input);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: formatErrors(result.error) };
+}
+function parseAtelier(yamlString) {
+  let parsed;
+  try {
+    parsed = yamlParse(yamlString);
+  } catch (err) {
+    return {
+      success: false,
+      errors: [{ path: "(yaml)", message: `YAML parse error: ${err.message}` }]
+    };
+  }
+  return validateDocument(parsed);
+}
+
+// ../math/dist/index.js
+function linear(t) {
+  return t;
+}
+function cubicBezier(x1, y1, x2, y2) {
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    let lo = 0;
+    let hi = 1;
+    let mid = 0;
+    for (let i = 0; i < 20; i++) {
+      mid = (lo + hi) / 2;
+      const x = sampleBezier(x1, x2, mid);
+      if (Math.abs(x - t) < 1e-6) break;
+      if (x < t) lo = mid;
+      else hi = mid;
+    }
+    mid = (lo + hi) / 2;
+    return sampleBezier(y1, y2, mid);
+  };
+}
+function sampleBezier(p1, p2, t) {
+  return 3 * (1 - t) * (1 - t) * t * p1 + 3 * (1 - t) * t * t * p2 + t * t * t;
+}
+var easeIn = cubicBezier(0.42, 0, 1, 1);
+var easeOut = cubicBezier(0, 0, 0.58, 1);
+var easeInOut = cubicBezier(0.42, 0, 0.58, 1);
+function step(steps, position = "end") {
+  return (t) => {
+    if (t <= 0) return position === "start" ? 1 / steps : 0;
+    if (t >= 1) return 1;
+    const s = Math.floor(t * steps);
+    if (position === "start") {
+      return Math.min((s + 1) / steps, 1);
+    }
+    return s / steps;
+  };
+}
+function spring(config = {}) {
+  const {
+    mass = 1,
+    stiffness = 100,
+    damping = 10,
+    velocity = 0
+  } = config;
+  const w0 = Math.sqrt(stiffness / mass);
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  const duration = estimateSettleTime(zeta, w0);
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    const time = t * duration;
+    let value;
+    if (zeta < 1) {
+      const wd = w0 * Math.sqrt(1 - zeta * zeta);
+      const A = 1;
+      const B = (zeta * w0 + velocity) / wd;
+      value = 1 - Math.exp(-zeta * w0 * time) * (A * Math.cos(wd * time) + B * Math.sin(wd * time));
+    } else if (zeta === 1) {
+      value = 1 - Math.exp(-w0 * time) * (1 + (w0 + velocity) * time);
+    } else {
+      const s1 = -w0 * (zeta - Math.sqrt(zeta * zeta - 1));
+      const s2 = -w0 * (zeta + Math.sqrt(zeta * zeta - 1));
+      const A = (velocity - s2) / (s1 - s2);
+      const B = 1 - A;
+      value = 1 - A * Math.exp(s1 * time) - B * Math.exp(s2 * time);
+    }
+    return value;
+  };
+}
+function estimateSettleTime(zeta, w0) {
+  if (zeta >= 1) {
+    return 10 / (zeta * w0);
+  }
+  return Math.log(1e3) / (zeta * w0);
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function hexToRgba(hex) {
+  let h = hex.replace("#", "");
+  if (h.length === 3)
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + "ff";
+  else if (h.length === 4)
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + h[3] + h[3];
+  else if (h.length === 6) h = h + "ff";
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16),
+    a: parseInt(h.slice(6, 8), 16) / 255
+  };
+}
+function rgbaToHex(color) {
+  const r = clamp(Math.round(color.r), 0, 255).toString(16).padStart(2, "0");
+  const g = clamp(Math.round(color.g), 0, 255).toString(16).padStart(2, "0");
+  const b = clamp(Math.round(color.b), 0, 255).toString(16).padStart(2, "0");
+  const a = clamp(Math.round(color.a * 255), 0, 255).toString(16).padStart(2, "0");
+  return `#${r}${g}${b}${a === "ff" ? "" : a}`;
+}
+function lerpRgba(a, b, t) {
+  return {
+    r: lerp(a.r, b.r, t),
+    g: lerp(a.g, b.g, t),
+    b: lerp(a.b, b.b, t),
+    a: lerp(a.a, b.a, t)
+  };
+}
+
+// ../core/dist/index.js
+function resolveEasing(easing) {
+  if (!easing) return linear;
+  if (typeof easing === "string") {
+    switch (easing) {
+      case "ease-in":
+        return easeIn;
+      case "ease-out":
+        return easeOut;
+      case "ease-in-out":
+        return easeInOut;
+      default:
+        return linear;
+    }
+  }
+  switch (easing.type) {
+    case "linear":
+      return linear;
+    case "cubic-bezier":
+      return cubicBezier(easing.x1, easing.y1, easing.x2, easing.y2);
+    case "spring":
+      return spring({
+        mass: easing.mass,
+        stiffness: easing.stiffness,
+        damping: easing.damping,
+        velocity: easing.velocity
+      });
+    case "step":
+      return step(easing.steps, easing.position);
+    default:
+      return linear;
+  }
+}
+function isFrameInRange(frame, range) {
+  return frame >= range[0] && frame <= range[1];
+}
+function computeProgress(frame, range) {
+  const [start, end] = range;
+  if (start === end) return 1;
+  return clamp((frame - start) / (end - start), 0, 1);
+}
+function resolveDeltaValue(delta, frame) {
+  if (!isFrameInRange(frame, delta.range)) {
+    return void 0;
+  }
+  const progress = computeProgress(frame, delta.range);
+  const easingFn = resolveEasing(delta.easing);
+  const easedProgress = easingFn(progress);
+  return interpolateValue(delta.from, delta.to, easedProgress);
+}
+function interpolateValue(from, to, t) {
+  if (typeof from === "number" && typeof to === "number") {
+    return lerp(from, to, t);
+  }
+  if (typeof from === "string" && typeof to === "string") {
+    if (from.startsWith("#") && to.startsWith("#")) {
+      return rgbaToHex(lerpRgba(hexToRgba(from), hexToRgba(to), t));
+    }
+    return t >= 1 ? to : from;
+  }
+  return t >= 1 ? to : from;
+}
+function resolvePropertyAtFrame(deltas, frame) {
+  for (const delta of deltas) {
+    if (isFrameInRange(frame, delta.range)) {
+      return resolveDeltaValue(delta, frame);
+    }
+  }
+  let lastCompleted;
+  for (const delta of deltas) {
+    if (frame > delta.range[1]) {
+      if (!lastCompleted || delta.range[1] > lastCompleted.range[1]) {
+        lastCompleted = delta;
+      }
+    }
+  }
+  return lastCompleted?.to;
+}
+function resolveFrame(doc, stateName, frame) {
+  const state = doc.states[stateName];
+  if (!state) {
+    throw new Error(`State "${stateName}" not found in document "${doc.name}"`);
+  }
+  const deltasByLayerProperty = groupDeltas(state.deltas);
+  const resolvedLayers = doc.layers.map((layer) => {
+    const computedProperties = {};
+    const layerDeltas = deltasByLayerProperty.get(layer.id);
+    if (layerDeltas) {
+      for (const [property, deltas] of layerDeltas) {
+        const value = resolvePropertyAtFrame(deltas, frame);
+        if (value !== void 0) {
+          computedProperties[property] = value;
+        }
+      }
+    }
+    return { id: layer.id, layer, computedProperties };
+  });
+  return { frame, stateName, layers: resolvedLayers };
+}
+function groupDeltas(deltas) {
+  const map = /* @__PURE__ */ new Map();
+  for (const delta of deltas) {
+    let layerMap = map.get(delta.layer);
+    if (!layerMap) {
+      layerMap = /* @__PURE__ */ new Map();
+      map.set(delta.layer, layerMap);
+    }
+    let propDeltas = layerMap.get(delta.property);
+    if (!propDeltas) {
+      propDeltas = [];
+      layerMap.set(delta.property, propDeltas);
+    }
+    propDeltas.push(delta);
+  }
+  return map;
+}
+function rangesOverlap(a, b) {
+  return a[0] <= b[1] && b[0] <= a[1];
+}
+function validateAllDeltas(deltas) {
+  const errors = [];
+  for (let i = 0; i < deltas.length; i++) {
+    for (let j = i + 1; j < deltas.length; j++) {
+      const a = deltas[i];
+      const b = deltas[j];
+      if (a.layer === b.layer && a.property === b.property && rangesOverlap(a.range, b.range)) {
+        errors.push({
+          layerId: a.layer,
+          property: a.property,
+          existingRange: a.range,
+          newRange: b.range,
+          message: `Overlapping deltas on layer "${a.layer}" property "${a.property}": [${a.range[0]}-${a.range[1]}] overlaps with [${b.range[0]}-${b.range[1]}]`
+        });
+      }
+    }
+  }
+  return errors;
+}
+
+// src/commands/validate.ts
+function validateFile(filePath) {
+  const absPath = resolve(filePath);
+  let content;
+  try {
+    content = readFileSync(absPath, "utf-8");
+  } catch {
+    return { valid: false, errors: [`Cannot read file: ${absPath}`] };
+  }
+  const result = parseAtelier(content);
+  if (!result.success) {
+    return {
+      valid: false,
+      errors: result.errors.map(
+        (e) => `${e.path}: ${e.message}`
+      )
+    };
+  }
+  const overlapErrors = [];
+  for (const [stateName, state] of Object.entries(result.data.states)) {
+    const overlaps = validateAllDeltas(state.deltas);
+    for (const overlap of overlaps) {
+      overlapErrors.push(`State "${stateName}": ${overlap.message}`);
+    }
+  }
+  if (overlapErrors.length > 0) {
+    return { valid: false, errors: overlapErrors };
+  }
+  return { valid: true, errors: [] };
+}
+function validateCommand(program) {
+  program.command("validate <file>").description("Validate an .atelier YAML file").action((file) => {
+    const { valid, errors } = validateFile(file);
+    if (valid) {
+      console.log("Valid");
+    } else {
+      console.error("Validation errors:");
+      for (const error of errors) {
+        console.error(`  - ${error}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/info.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function getInfo(doc) {
+  return {
+    name: doc.name,
+    description: doc.description,
+    canvas: {
+      width: doc.canvas.width,
+      height: doc.canvas.height,
+      fps: doc.canvas.fps,
+      background: doc.canvas.background
+    },
+    layers: {
+      count: doc.layers.length,
+      items: doc.layers.map((layer) => ({
+        id: layer.id,
+        type: layer.visual.type
+      }))
+    },
+    states: {
+      count: Object.keys(doc.states).length,
+      items: Object.entries(doc.states).map(([name, state]) => ({
+        name,
+        duration: state.duration,
+        deltaCount: state.deltas.length
+      }))
+    },
+    presets: {
+      count: doc.presets ? Object.keys(doc.presets).length : 0
+    }
+  };
+}
+function formatInfo(info) {
+  const lines = [];
+  lines.push(`Name: ${info.name}`);
+  if (info.description) {
+    lines.push(`Description: ${info.description}`);
+  }
+  const bg = info.canvas.background ? `, background: ${info.canvas.background}` : "";
+  lines.push(
+    `Canvas: ${info.canvas.width}x${info.canvas.height} @ ${info.canvas.fps}fps${bg}`
+  );
+  lines.push(`Layers: ${info.layers.count}`);
+  for (const layer of info.layers.items) {
+    lines.push(`  - ${layer.id} (${layer.type})`);
+  }
+  lines.push(`States: ${info.states.count}`);
+  for (const state of info.states.items) {
+    lines.push(
+      `  - ${state.name}: ${state.duration} frames, ${state.deltaCount} deltas`
+    );
+  }
+  if (info.presets.count > 0) {
+    lines.push(`Presets: ${info.presets.count}`);
+  }
+  return lines.join("\n");
+}
+function readAndParse(file) {
+  const absPath = resolve2(file);
+  let content;
+  try {
+    content = readFileSync2(absPath, "utf-8");
+  } catch {
+    console.error(`Cannot read file: ${absPath}`);
+    return process.exit(1);
+  }
+  const result = parseAtelier(content);
+  if (!result.success) {
+    console.error("Parse errors:");
+    for (const error of result.errors) {
+      console.error(`  - ${error.path}: ${error.message}`);
+    }
+    return process.exit(1);
+  }
+  return result.data;
+}
+function infoCommand(program) {
+  program.command("info <file>").description("Display summary info for an .atelier file").action((file) => {
+    const doc = readAndParse(file);
+    const info = getInfo(doc);
+    console.log(formatInfo(info));
+  });
+}
+
+// src/commands/still.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+function resolveStill(doc, stateName, frame) {
+  const stateNames = Object.keys(doc.states);
+  if (stateNames.length === 0) {
+    throw new Error("Document has no states");
+  }
+  const resolvedStateName = stateName ?? stateNames[0];
+  if (!(resolvedStateName in doc.states)) {
+    throw new Error(
+      `State "${resolvedStateName}" not found. Available: ${stateNames.join(", ")}`
+    );
+  }
+  const resolvedFrame = frame ?? 0;
+  return resolveFrame(doc, resolvedStateName, resolvedFrame);
+}
+function readAndParse2(file) {
+  const absPath = resolve3(file);
+  let content;
+  try {
+    content = readFileSync3(absPath, "utf-8");
+  } catch {
+    console.error(`Cannot read file: ${absPath}`);
+    return process.exit(1);
+  }
+  const result = parseAtelier(content);
+  if (!result.success) {
+    console.error("Parse errors:");
+    for (const error of result.errors) {
+      console.error(`  - ${error.path}: ${error.message}`);
+    }
+    return process.exit(1);
+  }
+  return result.data;
+}
+function stillCommand(program) {
+  program.command("still <file>").description(
+    "Resolve a single frame and output as JSON"
+  ).option("-s, --state <name>", "State name (defaults to first state)").option(
+    "-f, --frame <number>",
+    "Frame number (defaults to 0)",
+    "0"
+  ).action(
+    (file, options) => {
+      const doc = readAndParse2(file);
+      const frameNumber = parseInt(options.frame, 10);
+      if (isNaN(frameNumber) || frameNumber < 0) {
+        console.error(
+          `Invalid frame number: ${options.frame}`
+        );
+        process.exit(1);
+        return;
+      }
+      try {
+        const resolved = resolveStill(
+          doc,
+          options.state,
+          frameNumber
+        );
+        console.log(JSON.stringify(resolved, null, 2));
+      } catch (err) {
+        console.error(
+          err.message
+        );
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/render-pipeline.ts
+import { spawn } from "child_process";
+
+// ../canvas/dist/index.js
+function colorToCSS(color) {
+  if (typeof color === "string") return color;
+  if ("r" in color) {
+    const c = color;
+    return `rgba(${Math.round(c.r)}, ${Math.round(c.g)}, ${Math.round(c.b)}, ${c.a})`;
+  }
+  if ("h" in color) {
+    const c = color;
+    return `hsla(${c.h}, ${c.s}%, ${c.l}%, ${c.a})`;
+  }
+  return "#000000";
+}
+function applyFill(ctx, fill, width, height) {
+  switch (fill.type) {
+    case "solid":
+      ctx.fillStyle = colorToCSS(fill.color);
+      break;
+    case "linear-gradient": {
+      const rad = fill.angle * Math.PI / 180;
+      const cos = Math.cos(rad);
+      const sin = Math.sin(rad);
+      const halfW = width / 2;
+      const halfH = height / 2;
+      const grad = ctx.createLinearGradient(
+        halfW - cos * halfW,
+        halfH - sin * halfH,
+        halfW + cos * halfW,
+        halfH + sin * halfH
+      );
+      for (const stop of fill.stops) {
+        grad.addColorStop(stop.offset, colorToCSS(stop.color));
+      }
+      ctx.fillStyle = grad;
+      break;
+    }
+    case "radial-gradient": {
+      const cx = typeof fill.center.x === "number" ? fill.center.x : parseFloat(fill.center.x) / 100 * width;
+      const cy = typeof fill.center.y === "number" ? fill.center.y : parseFloat(fill.center.y) / 100 * height;
+      const r = typeof fill.radius === "number" ? fill.radius : parseFloat(fill.radius) / 100 * Math.max(width, height);
+      const grad = ctx.createRadialGradient(cx, cy, 0, cx, cy, r);
+      for (const stop of fill.stops) {
+        grad.addColorStop(stop.offset, colorToCSS(stop.color));
+      }
+      ctx.fillStyle = grad;
+      break;
+    }
+  }
+}
+function applyStroke(ctx, stroke, pathLength) {
+  ctx.strokeStyle = colorToCSS(stroke.color);
+  ctx.lineWidth = stroke.width;
+  if (stroke.lineCap) ctx.lineCap = stroke.lineCap;
+  if (stroke.lineJoin) ctx.lineJoin = stroke.lineJoin;
+  const start = stroke.strokeStart ?? 0;
+  const end = stroke.strokeEnd ?? 1;
+  if (start !== 0 || end !== 1) {
+    const visible = (end - start) * pathLength;
+    ctx.setLineDash([Math.max(visible, 0), pathLength + 1]);
+    ctx.lineDashOffset = -start * pathLength;
+  } else if (stroke.dash) {
+    ctx.setLineDash(stroke.dash);
+  }
+}
+function resolveUnit(value, reference) {
+  if (typeof value === "string" && value.endsWith("%")) {
+    return parseFloat(value) / 100 * reference;
+  }
+  return value;
+}
+function buildEffectiveLayer(resolved, parentWidth, parentHeight) {
+  const { layer, computedProperties } = resolved;
+  const cp = computedProperties;
+  const hasShadow = layer.shadow || cp["shadow.blur"] !== void 0 || cp["shadow.color"] !== void 0;
+  return {
+    layer,
+    visual: buildEffectiveVisual(layer.visual, cp),
+    x: resolveUnit(cp["frame.x"] ?? layer.frame.x, parentWidth),
+    y: resolveUnit(cp["frame.y"] ?? layer.frame.y, parentHeight),
+    width: resolveUnit(cp["bounds.width"] ?? layer.bounds.width, parentWidth),
+    height: resolveUnit(cp["bounds.height"] ?? layer.bounds.height, parentHeight),
+    opacity: cp["opacity"] ?? layer.opacity ?? 1,
+    rotation: cp["rotation"] ?? layer.rotation ?? 0,
+    scaleX: cp["scale.x"] ?? layer.scale?.x ?? 1,
+    scaleY: cp["scale.y"] ?? layer.scale?.y ?? 1,
+    anchorX: cp["anchorPoint.x"] ?? layer.anchorPoint?.x ?? 0,
+    anchorY: cp["anchorPoint.y"] ?? layer.anchorPoint?.y ?? 0,
+    shadow: hasShadow ? {
+      color: colorToCSS(cp["shadow.color"] ?? layer.shadow?.color ?? "#00000080"),
+      blur: cp["shadow.blur"] ?? layer.shadow?.blur ?? 0,
+      offsetX: cp["shadow.offsetX"] ?? layer.shadow?.offsetX ?? 0,
+      offsetY: cp["shadow.offsetY"] ?? layer.shadow?.offsetY ?? 0
+    } : void 0
+  };
+}
+function buildEffectiveVisual(visual, cp) {
+  const hasVisualOverride = cp["visual.fill.color"] !== void 0 || cp["visual.stroke.color"] !== void 0 || cp["visual.stroke.width"] !== void 0 || cp["visual.stroke.start"] !== void 0 || cp["visual.stroke.end"] !== void 0 || cp["visual.shape.cornerRadius"] !== void 0 || cp["visual.style.fontSize"] !== void 0 || cp["visual.style.color"] !== void 0;
+  if (!hasVisualOverride) return visual;
+  if (visual.type === "shape") {
+    const v = { ...visual };
+    if (cp["visual.shape.cornerRadius"] !== void 0 && v.shape.type === "rect") {
+      v.shape = { ...v.shape, cornerRadius: cp["visual.shape.cornerRadius"] };
+    }
+    if (v.fill && cp["visual.fill.color"] !== void 0) {
+      v.fill = v.fill.type === "solid" ? { ...v.fill, color: cp["visual.fill.color"] } : v.fill;
+    }
+    if (v.stroke) {
+      const strokeColor = cp["visual.stroke.color"] ?? v.stroke.color;
+      const strokeWidth = cp["visual.stroke.width"] ?? v.stroke.width;
+      const strokeStart = cp["visual.stroke.start"] ?? v.stroke.strokeStart;
+      const strokeEnd = cp["visual.stroke.end"] ?? v.stroke.strokeEnd;
+      if (strokeColor !== v.stroke.color || strokeWidth !== v.stroke.width || strokeStart !== v.stroke.strokeStart || strokeEnd !== v.stroke.strokeEnd) {
+        v.stroke = {
+          ...v.stroke,
+          color: strokeColor,
+          width: strokeWidth,
+          strokeStart,
+          strokeEnd
+        };
+      }
+    }
+    return v;
+  }
+  if (visual.type === "text") {
+    const v = { ...visual };
+    const fontSize = cp["visual.style.fontSize"] ?? v.style.fontSize;
+    const color = cp["visual.style.color"] ?? v.style.color;
+    if (fontSize !== v.style.fontSize || color !== v.style.color) {
+      v.style = { ...v.style, fontSize, color };
+    }
+    return v;
+  }
+  return visual;
+}
+function renderShape(ctx, eff) {
+  const visual = eff.visual;
+  const { shape } = visual;
+  const { width, height } = eff;
+  switch (shape.type) {
+    case "rect":
+      renderRect(ctx, width, height, shape.cornerRadius, visual);
+      break;
+    case "ellipse":
+      renderEllipse(ctx, width, height, visual);
+      break;
+    case "path":
+      renderPath(ctx, shape.points, shape.closed, visual);
+      break;
+  }
+}
+function rectPerimeter(w, h) {
+  return 2 * (w + h);
+}
+function ellipsePerimeter(w, h) {
+  const a = w / 2;
+  const b = h / 2;
+  return Math.PI * (3 * (a + b) - Math.sqrt((3 * a + b) * (a + 3 * b)));
+}
+function dist(x1, y1, x2, y2) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function pathPerimeter(points, closed) {
+  let length = 0;
+  for (let i = 1; i < points.length; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    if (prev.out && curr.in) {
+      length += dist(prev.x, prev.y, curr.x, curr.y) * 1.2;
+    } else {
+      length += dist(prev.x, prev.y, curr.x, curr.y);
+    }
+  }
+  if (closed && points.length > 1) {
+    const first = points[0];
+    const last = points[points.length - 1];
+    length += dist(last.x, last.y, first.x, first.y);
+  }
+  return length;
+}
+function renderRect(ctx, width, height, cornerRadius, visual) {
+  if (visual.fill) {
+    applyFill(ctx, visual.fill, width, height);
+    if (cornerRadius && ctx.roundRect) {
+      ctx.beginPath();
+      ctx.roundRect(0, 0, width, height, cornerRadius);
+      ctx.fill();
+    } else {
+      ctx.fillRect(0, 0, width, height);
+    }
+  }
+  if (visual.stroke) {
+    const perimeter = rectPerimeter(width, height);
+    applyStroke(ctx, visual.stroke, perimeter);
+    if (cornerRadius && ctx.roundRect) {
+      ctx.beginPath();
+      ctx.roundRect(0, 0, width, height, cornerRadius);
+      ctx.stroke();
+    } else {
+      ctx.strokeRect(0, 0, width, height);
+    }
+  }
+}
+function renderEllipse(ctx, width, height, visual) {
+  ctx.beginPath();
+  ctx.ellipse(width / 2, height / 2, width / 2, height / 2, 0, 0, Math.PI * 2);
+  if (visual.fill) {
+    applyFill(ctx, visual.fill, width, height);
+    ctx.fill();
+  }
+  if (visual.stroke) {
+    const perimeter = ellipsePerimeter(width, height);
+    applyStroke(ctx, visual.stroke, perimeter);
+    ctx.stroke();
+  }
+}
+function renderPath(ctx, points, closed, visual) {
+  if (points.length < 2) return;
+  ctx.beginPath();
+  ctx.moveTo(points[0].x, points[0].y);
+  for (let i = 1; i < points.length; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    if (prev.out && curr.in) {
+      ctx.bezierCurveTo(
+        prev.x + prev.out.x,
+        prev.y + prev.out.y,
+        curr.x + curr.in.x,
+        curr.y + curr.in.y,
+        curr.x,
+        curr.y
+      );
+    } else {
+      ctx.lineTo(curr.x, curr.y);
+    }
+  }
+  if (closed) ctx.closePath();
+  if (visual.fill) {
+    applyFill(ctx, visual.fill, 0, 0);
+    ctx.fill();
+  }
+  if (visual.stroke) {
+    const perimeter = pathPerimeter(points, closed);
+    applyStroke(ctx, visual.stroke, perimeter);
+    ctx.stroke();
+  }
+}
+function renderText(ctx, eff) {
+  const visual = eff.visual;
+  const { style } = visual;
+  const fontStyle = style.fontStyle ?? "normal";
+  const fontWeight = style.fontWeight ?? "normal";
+  const fontSize = style.fontSize;
+  const fontFamily = style.fontFamily;
+  ctx.font = `${fontStyle} ${fontWeight} ${fontSize}px ${fontFamily}`;
+  const align = style.textAlign ?? "left";
+  ctx.textAlign = align;
+  ctx.textBaseline = "top";
+  ctx.fillStyle = colorToCSS(style.color);
+  let textX = 0;
+  if (align === "center") {
+    textX = eff.width / 2;
+  } else if (align === "right") {
+    textX = eff.width;
+  }
+  ctx.fillText(visual.content, textX, 0);
+}
+function renderImage(ctx, eff, imageCache) {
+  const visual = eff.visual;
+  const src = visual.src;
+  if (!src) return;
+  const img = imageCache.get(src);
+  if (!img) {
+    imageCache.load(src);
+    return;
+  }
+  ctx.drawImage(img, 0, 0, eff.width, eff.height);
+}
+function renderRef(ctx, eff) {
+  const visual = eff.visual;
+  const { width, height } = eff;
+  ctx.strokeStyle = "#888888";
+  ctx.lineWidth = 2;
+  ctx.setLineDash([6, 4]);
+  ctx.strokeRect(0, 0, width, height);
+  ctx.setLineDash([]);
+  const label = `REF: ${visual.src}`;
+  ctx.fillStyle = "#888888";
+  ctx.font = `${Math.max(12, Math.min(16, height * 0.15))}px sans-serif`;
+  ctx.textAlign = "center";
+  ctx.textBaseline = "middle";
+  ctx.fillText(label, width / 2, height / 2, width - 8);
+}
+function renderFrame(ctx, resolvedFrame, doc, imageCache) {
+  const { width, height } = doc.canvas;
+  ctx.fillStyle = doc.canvas.background ?? "transparent";
+  ctx.fillRect(0, 0, width, height);
+  const effMap = /* @__PURE__ */ new Map();
+  const effList = [];
+  for (const resolvedLayer of resolvedFrame.layers) {
+    const eff = buildEffectiveLayer(resolvedLayer, width, height);
+    effMap.set(resolvedLayer.layer.id, eff);
+    effList.push(eff);
+  }
+  for (const eff of effList) {
+    const { layer } = eff;
+    if (layer.visible === false) continue;
+    if (eff.opacity <= 0) continue;
+    if (layer.visual.type === "image") {
+      const iv = eff.visual;
+      if (!iv.src && iv.assetId && doc.assets?.[iv.assetId]) {
+        iv.src = doc.assets[iv.assetId].src;
+      }
+    }
+    ctx.save();
+    applyAncestorTransforms(ctx, layer.id, effMap, doc);
+    ctx.globalAlpha = eff.opacity;
+    ctx.translate(eff.x, eff.y);
+    const anchorPixelX = eff.anchorX * eff.width;
+    const anchorPixelY = eff.anchorY * eff.height;
+    if (eff.rotation !== 0 || eff.scaleX !== 1 || eff.scaleY !== 1) {
+      ctx.translate(anchorPixelX, anchorPixelY);
+      if (eff.rotation !== 0) {
+        ctx.rotate(eff.rotation * Math.PI / 180);
+      }
+      if (eff.scaleX !== 1 || eff.scaleY !== 1) {
+        ctx.scale(eff.scaleX, eff.scaleY);
+      }
+      ctx.translate(-anchorPixelX, -anchorPixelY);
+    }
+    if (eff.shadow) {
+      ctx.shadowColor = eff.shadow.color;
+      ctx.shadowBlur = eff.shadow.blur;
+      ctx.shadowOffsetX = eff.shadow.offsetX;
+      ctx.shadowOffsetY = eff.shadow.offsetY;
+    }
+    switch (layer.visual.type) {
+      case "shape":
+        renderShape(ctx, eff);
+        break;
+      case "text":
+        renderText(ctx, eff);
+        break;
+      case "image":
+        if (imageCache) renderImage(ctx, eff, imageCache);
+        break;
+      case "group":
+        break;
+      case "ref":
+        renderRef(ctx, eff);
+        break;
+    }
+    ctx.restore();
+  }
+}
+function applyAncestorTransforms(ctx, layerId, effMap, doc) {
+  const chain = [];
+  const layer = doc.layers.find((l) => l.id === layerId);
+  let parentId = layer?.parentId;
+  const visited = /* @__PURE__ */ new Set();
+  while (parentId && !visited.has(parentId)) {
+    visited.add(parentId);
+    const parentEff = effMap.get(parentId);
+    if (!parentEff) break;
+    chain.push(parentEff);
+    parentId = parentEff.layer.parentId;
+  }
+  for (let i = chain.length - 1; i >= 0; i--) {
+    const p = chain[i];
+    ctx.translate(p.x, p.y);
+    const ax = p.anchorX * p.width;
+    const ay = p.anchorY * p.height;
+    if (p.rotation !== 0 || p.scaleX !== 1 || p.scaleY !== 1) {
+      ctx.translate(ax, ay);
+      if (p.rotation !== 0) ctx.rotate(p.rotation * Math.PI / 180);
+      if (p.scaleX !== 1 || p.scaleY !== 1) ctx.scale(p.scaleX, p.scaleY);
+      ctx.translate(-ax, -ay);
+    }
+  }
+}
+var ImageCache = class {
+  cache = /* @__PURE__ */ new Map();
+  loading = /* @__PURE__ */ new Set();
+  onLoad;
+  createImage;
+  constructor(opts) {
+    this.onLoad = opts?.onLoad;
+    this.createImage = opts?.createImage;
+  }
+  get(src) {
+    const entry = this.cache.get(src);
+    return entry?.complete ? entry.image : null;
+  }
+  load(src) {
+    if (this.cache.has(src) || this.loading.has(src)) return;
+    if (!this.createImage) return;
+    this.loading.add(src);
+    const image = this.createImage(
+      src,
+      () => {
+        this.cache.set(src, { complete: true, image });
+        this.loading.delete(src);
+        this.onLoad?.();
+      },
+      () => {
+        this.loading.delete(src);
+      }
+    );
+  }
+};
+
+// src/commands/render-pipeline.ts
+async function checkFfmpeg() {
+  return new Promise((resolve5) => {
+    const proc = spawn("ffmpeg", ["-version"], { stdio: "pipe" });
+    proc.on("error", () => resolve5(false));
+    proc.on("close", (code) => resolve5(code === 0));
+  });
+}
+function buildFfmpegArgs(width, height, fps, format, output) {
+  const input = [
+    "-y",
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "bgra",
+    "-s",
+    `${width}x${height}`,
+    "-r",
+    String(fps),
+    "-i",
+    "pipe:0"
+  ];
+  if (format === "mp4") {
+    return [
+      ...input,
+      "-c:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      "-preset",
+      "medium",
+      "-crf",
+      "18",
+      "-movflags",
+      "+faststart",
+      output
+    ];
+  }
+  return [
+    ...input,
+    "-vf",
+    "split[s0][s1];[s0]palettegen=stats_mode=single[p];[s1][p]paletteuse=dither=sierra2_4a",
+    "-loop",
+    "0",
+    output
+  ];
+}
+async function preloadImages(doc, loadImage) {
+  const sources = /* @__PURE__ */ new Set();
+  for (const layer of doc.layers) {
+    if (layer.visual.type === "image") {
+      const iv = layer.visual;
+      if (iv.src) {
+        sources.add(iv.src);
+      } else if (iv.assetId && doc.assets?.[iv.assetId]) {
+        sources.add(doc.assets[iv.assetId].src);
+      }
+    }
+  }
+  if (sources.size === 0) {
+    return new ImageCache();
+  }
+  const preloaded = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...sources].map(async (src) => {
+      try {
+        preloaded.set(src, await loadImage(src));
+      } catch {
+      }
+    })
+  );
+  const imageCache = new ImageCache({
+    createImage: (src, onLoad, onError) => {
+      const img = preloaded.get(src);
+      if (img) {
+        process.nextTick(onLoad);
+        return img;
+      }
+      process.nextTick(onError);
+      return {};
+    }
+  });
+  for (const src of preloaded.keys()) {
+    imageCache.load(src);
+  }
+  await new Promise((resolve5) => process.nextTick(resolve5));
+  return imageCache;
+}
+async function renderDocument(doc, opts) {
+  const canvasModuleName = "canvas";
+  let createCanvas;
+  let loadImage;
+  try {
+    const canvasModule = await import(
+      /* webpackIgnore: true */
+      canvasModuleName
+    );
+    createCanvas = canvasModule.createCanvas;
+    loadImage = canvasModule.loadImage;
+  } catch {
+    throw new Error(
+      "The 'canvas' package is not installed.\nInstall it with:\n  npm install canvas\nPrerequisites vary by OS:\n  macOS:   brew install pkg-config cairo pango libpng jpeg giflib librsvg pixman\n  Ubuntu:  sudo apt install build-essential libcairo2-dev libpango1.0-dev libjpeg-dev libgif-dev librsvg2-dev\nSee: https://github.com/Automattic/node-canvas#compiling"
+    );
+  }
+  const { width, height, fps } = doc.canvas;
+  const { output, format, states, onProgress } = opts;
+  if (format === "mp4" && (width % 2 !== 0 || height % 2 !== 0)) {
+    throw new Error(
+      `H.264 requires even dimensions. Canvas is ${width}\xD7${height}. Try ${width + width % 2}\xD7${height + height % 2}.`
+    );
+  }
+  const allStates = Object.keys(doc.states);
+  const renderStates = states ?? allStates;
+  for (const s of renderStates) {
+    if (!(s in doc.states)) {
+      throw new Error(
+        `State "${s}" not found. Available: ${allStates.join(", ")}`
+      );
+    }
+  }
+  let totalFrames = 0;
+  for (const s of renderStates) {
+    totalFrames += doc.states[s].duration;
+  }
+  if (totalFrames === 0) {
+    throw new Error("Nothing to render \u2014 all states have duration 0");
+  }
+  const imageCache = await preloadImages(doc, loadImage);
+  const canvas = createCanvas(width, height);
+  const ctx = canvas.getContext("2d");
+  const ffmpegArgs = buildFfmpegArgs(width, height, fps, format, output);
+  const ffmpeg = spawn("ffmpeg", ffmpegArgs, {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let stderrOutput = "";
+  ffmpeg.stderr?.on("data", (chunk) => {
+    stderrOutput += chunk.toString();
+  });
+  const startTime = Date.now();
+  let frameIndex = 0;
+  for (const stateName of renderStates) {
+    const duration = doc.states[stateName].duration;
+    for (let f = 0; f < duration; f++) {
+      const resolved = resolveFrame(doc, stateName, f);
+      renderFrame(ctx, resolved, doc, imageCache);
+      const raw = canvas.toBuffer("raw");
+      const canWrite = ffmpeg.stdin.write(raw);
+      if (!canWrite) {
+        await new Promise(
+          (resolve5) => ffmpeg.stdin.once("drain", resolve5)
+        );
+      }
+      frameIndex++;
+      onProgress?.({
+        frame: frameIndex,
+        totalFrames,
+        state: stateName,
+        percent: Math.round(frameIndex / totalFrames * 100)
+      });
+    }
+  }
+  ffmpeg.stdin.end();
+  const exitCode = await new Promise((resolve5) => {
+    ffmpeg.on("close", resolve5);
+  });
+  if (exitCode !== 0) {
+    throw new Error(
+      `FFmpeg exited with code ${exitCode}.
+${stderrOutput.slice(-500)}`
+    );
+  }
+  return {
+    output,
+    format,
+    totalFrames,
+    states: renderStates,
+    durationMs: Date.now() - startTime
+  };
+}
+
+// src/commands/render.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve4, basename, extname } from "path";
+function readAndParse3(file) {
+  const absPath = resolve4(file);
+  let content;
+  try {
+    content = readFileSync4(absPath, "utf-8");
+  } catch {
+    console.error(`Cannot read file: ${absPath}`);
+    return process.exit(1);
+  }
+  const result = parseAtelier(content);
+  if (!result.success) {
+    console.error("Parse errors:");
+    for (const error of result.errors) {
+      console.error(`  - ${error.path}: ${error.message}`);
+    }
+    return process.exit(1);
+  }
+  return result.data;
+}
+function inferFormat(output) {
+  if (!output) return "mp4";
+  const ext = extname(output).toLowerCase();
+  if (ext === ".gif") return "gif";
+  return "mp4";
+}
+function renderCommand(program) {
+  program.command("render <file>").description("Render animation to MP4 or GIF via FFmpeg").option("-o, --output <path>", "Output file path").option("-f, --format <type>", "Output format: mp4 | gif").option(
+    "-s, --state <names...>",
+    "State(s) to render (default: all in order)"
+  ).action(
+    async (file, options) => {
+      const hasFfmpeg = await checkFfmpeg();
+      if (!hasFfmpeg) {
+        console.error("FFmpeg is not installed or not in PATH.");
+        console.error("Install it:");
+        console.error("  macOS:   brew install ffmpeg");
+        console.error("  Ubuntu:  sudo apt install ffmpeg");
+        console.error("  Windows: https://ffmpeg.org/download.html");
+        process.exit(1);
+        return;
+      }
+      const doc = readAndParse3(file);
+      let format;
+      if (options.format) {
+        if (options.format !== "mp4" && options.format !== "gif") {
+          console.error(
+            `Unknown format: "${options.format}". Use mp4 or gif.`
+          );
+          process.exit(1);
+          return;
+        }
+        format = options.format;
+      } else {
+        format = inferFormat(options.output);
+      }
+      const inputName = basename(file, extname(file));
+      const output = options.output ?? `${inputName}.${format}`;
+      const startTime = Date.now();
+      try {
+        const result = await renderDocument(doc, {
+          output: resolve4(output),
+          format,
+          states: options.state,
+          onProgress: ({ frame, totalFrames, state, percent }) => {
+            const elapsed = (Date.now() - startTime) / 1e3;
+            const rate = elapsed > 0 ? frame / elapsed : 0;
+            const remaining = rate > 0 ? (totalFrames - frame) / rate : 0;
+            process.stderr.write(
+              `\rRendering: frame ${frame}/${totalFrames} (${percent}%) - state "${state}" - ETA ${remaining.toFixed(1)}s`
+            );
+          }
+        });
+        process.stderr.write("\n");
+        console.log(
+          `Done: ${result.totalFrames} frames \u2192 ${result.output} (${(result.durationMs / 1e3).toFixed(1)}s)`
+        );
+      } catch (err) {
+        process.stderr.write("\n");
+        console.error(err.message);
+        process.exit(1);
+      }
+    }
+  );
+}
+
+export {
+  validateFile,
+  validateCommand,
+  getInfo,
+  infoCommand,
+  resolveStill,
+  stillCommand,
+  checkFfmpeg,
+  buildFfmpegArgs,
+  renderDocument,
+  renderCommand
+};
+//# sourceMappingURL=chunk-LL2EJ6YE.js.map