@a-company/atelier 0.29.0 → 0.36.0

package/dist/chunk-JV7RGETS.js

@@ -1,2292 +0,0 @@
-import {
-  ImageCache,
-  buildEffectiveLayer,
-  findTemplateVariables,
-  renderFrame,
-  resolveFrame,
-  validateAllDeltas
-} from "./chunk-JPZ4F4PW.js";
-
-// 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 z8 } from "zod";
-import { z as z7 } 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 { z as z14 } 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(["linear", "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 TriggerTypeSchema = z7.enum([
-  "click",
-  "hover",
-  "pointerdown",
-  "pointerup",
-  "timer",
-  "signal"
-]);
-var TriggerSchema = z7.object({
-  type: TriggerTypeSchema,
-  delay: z7.number().nonnegative("Timer delay must be non-negative").optional(),
-  signal: z7.string().optional()
-}).refine(
-  (t) => t.type !== "timer" || t.delay !== void 0,
-  { message: "Timer trigger requires a delay" }
-).refine(
-  (t) => t.type !== "signal" || t.signal !== void 0,
-  { message: "Signal trigger requires a signal name" }
-);
-var ActionTypeSchema = z7.enum([
-  "go-to-state",
-  "emit-signal",
-  "set-variable",
-  "toggle-visibility"
-]);
-var ActionSchema = z7.object({
-  type: ActionTypeSchema,
-  state: z7.string().optional(),
-  signal: z7.string().optional(),
-  variable: z7.string().optional(),
-  value: z7.unknown().optional(),
-  targetLayer: z7.string().optional()
-}).refine(
-  (a) => a.type !== "go-to-state" || a.state !== void 0,
-  { message: "go-to-state action requires a state name" }
-).refine(
-  (a) => a.type !== "emit-signal" || a.signal !== void 0,
-  { message: "emit-signal action requires a signal name" }
-).refine(
-  (a) => a.type !== "set-variable" || a.variable !== void 0 && a.value !== void 0,
-  { message: "set-variable action requires variable and value" }
-);
-var InteractionSchema = z7.object({
-  id: z7.string().min(1, "Interaction id is required"),
-  trigger: TriggerSchema,
-  action: ActionSchema,
-  description: z7.string().optional()
-});
-var BlendModeSchema = z8.enum([
-  "normal",
-  "multiply",
-  "screen",
-  "overlay",
-  "darken",
-  "lighten",
-  "color-dodge",
-  "color-burn",
-  "hard-light",
-  "soft-light",
-  "difference",
-  "exclusion",
-  "hue",
-  "saturation",
-  "color",
-  "luminosity"
-]);
-var MotionPathSchema = z8.object({
-  points: z8.array(PathPointSchema).min(2, "Motion path must have at least 2 points"),
-  closed: z8.boolean().optional(),
-  autoRotate: z8.boolean().optional(),
-  autoRotateOffset: z8.number().optional()
-});
-var ShapeVisualSchema = z8.object({
-  type: z8.literal("shape"),
-  shape: ShapeSchema,
-  fill: FillSchema.optional(),
-  stroke: StrokeSchema.optional()
-});
-var TextVisualSchema = z8.object({
-  type: z8.literal("text"),
-  content: z8.string(),
-  style: TextStyleSchema
-});
-var SpritesheetConfigSchema = z8.object({
-  columns: z8.number().int().positive(),
-  rows: z8.number().int().positive(),
-  frameCount: z8.number().int().positive().optional(),
-  frameWidth: z8.number().positive(),
-  frameHeight: z8.number().positive()
-});
-var SourceRectSchema = z8.object({
-  x: z8.number(),
-  y: z8.number(),
-  width: z8.number().positive(),
-  height: z8.number().positive()
-});
-var ImageVisualSchema = z8.object({
-  type: z8.literal("image"),
-  assetId: z8.string().min(1, "assetId is required"),
-  src: z8.string().optional(),
-  sourceRect: SourceRectSchema.optional(),
-  spritesheet: SpritesheetConfigSchema.optional(),
-  frameIndex: z8.number().int().min(0).optional()
-});
-var VideoVisualSchema = z8.object({
-  type: z8.literal("video"),
-  assetId: z8.string().min(1, "assetId is required"),
-  src: z8.string().optional(),
-  startFrame: z8.number().int().min(0).optional(),
-  sourceOffset: z8.number().min(0).optional(),
-  sourceEnd: z8.number().positive().optional(),
-  playbackRate: z8.number().positive().optional(),
-  volume: z8.number().min(0).max(1).optional(),
-  muted: z8.boolean().optional(),
-  objectFit: z8.enum(["contain", "cover", "fill"]).optional()
-});
-var GroupVisualSchema = z8.object({
-  type: z8.literal("group")
-});
-var RefVisualSchema = z8.object({
-  type: z8.literal("ref"),
-  src: z8.string().min(1, "src is required"),
-  state: z8.string().optional(),
-  frame: z8.number().int().min(0).optional()
-});
-var VisualSchema = z8.discriminatedUnion("type", [
-  ShapeVisualSchema,
-  TextVisualSchema,
-  ImageVisualSchema,
-  VideoVisualSchema,
-  GroupVisualSchema,
-  RefVisualSchema
-]);
-var LayerSchema = z8.object({
-  id: z8.string().min(1, "Layer id is required"),
-  description: z8.string().optional(),
-  tags: z8.array(z8.string()).optional(),
-  visual: VisualSchema,
-  frame: FrameSchema,
-  bounds: BoundsSchema,
-  anchorPoint: AnchorPointSchema.optional(),
-  parentId: z8.string().optional(),
-  opacity: z8.number().min(0).max(1).optional(),
-  rotation: z8.number().optional(),
-  scale: z8.object({ x: z8.number(), y: z8.number() }).optional(),
-  visible: z8.boolean().optional(),
-  shadow: ShadowSchema.optional(),
-  blendMode: BlendModeSchema.optional(),
-  motionPath: MotionPathSchema.optional(),
-  clipPath: ShapeSchema.optional(),
-  tint: z8.object({
-    color: z8.string(),
-    amount: z8.number().min(0).max(1)
-  }).optional(),
-  interactions: z8.array(InteractionSchema).optional()
-});
-var AnimatablePropertySchema = z9.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",
-  "motionPath.progress",
-  "visual.fill.angle",
-  "visual.fill.center.x",
-  "visual.fill.center.y",
-  "visual.fill.radius",
-  "visual.image.sourceRect.x",
-  "visual.image.sourceRect.y",
-  "visual.image.sourceRect.width",
-  "visual.image.sourceRect.height",
-  "visual.image.frameIndex",
-  "visible",
-  "tint.color",
-  "tint.amount"
-]);
-var FrameRangeSchema = z9.tuple([
-  z9.number().int().min(0, "Frame start must be >= 0"),
-  z9.number().int().min(0, "Frame end must be >= 0")
-]).refine(([start, end]) => end >= start, {
-  message: "Frame range end must be >= start"
-});
-var DeltaSchema = z9.object({
-  id: z9.string().optional(),
-  name: z9.string().optional(),
-  layer: z9.string().min(1, "Delta must reference a layer id"),
-  property: AnimatablePropertySchema,
-  range: FrameRangeSchema,
-  from: z9.unknown(),
-  to: z9.unknown(),
-  easing: EasingSchema.optional(),
-  description: z9.string().optional(),
-  tags: z9.array(z9.string()).optional()
-});
-var AudioSchema = z10.object({
-  src: z10.string().min(1, "Audio src is required"),
-  offset: z10.number().min(0, "Audio offset must be non-negative").optional(),
-  volume: z10.number().min(0).max(1, "Audio volume must be 0\u20131").optional(),
-  loop: z10.boolean().optional(),
-  startFrame: z10.number().int().min(0, "Audio startFrame must be a non-negative integer").optional()
-});
-var StateTransitionConfigSchema = z10.object({
-  duration: z10.number().int().positive("Transition duration must be a positive integer (frames)"),
-  easing: EasingSchema.optional()
-});
-var StateSchema = z10.object({
-  description: z10.string().optional(),
-  tags: z10.array(z10.string()).optional(),
-  parent: z10.string().optional(),
-  duration: z10.number().int().positive("State duration must be a positive integer (frames)"),
-  deltas: z10.array(DeltaSchema),
-  audio: AudioSchema.optional(),
-  transitions: z10.record(z10.string(), StateTransitionConfigSchema).optional()
-});
-var PresetDeltaSchema = z11.object({
-  property: AnimatablePropertySchema,
-  offset: z11.tuple([z11.number().int().min(0), z11.number().int().min(0)]).optional(),
-  from: z11.unknown(),
-  to: z11.unknown(),
-  easing: EasingSchema.optional()
-});
-var PresetSchema = z11.object({
-  description: z11.string().optional(),
-  tags: z11.array(z11.string()).optional(),
-  deltas: z11.array(PresetDeltaSchema).min(1, "Preset must have at least one delta")
-});
-var VariableTypeSchema = z12.enum(["string", "number", "color", "asset", "boolean"]);
-var VariableSchema = z12.object({
-  type: VariableTypeSchema,
-  default: z12.unknown().optional(),
-  description: z12.string().optional()
-});
-var AssetTypeSchema = z13.enum(["image", "svg", "font", "animation", "audio", "video"]);
-var AssetSchema = z13.object({
-  type: AssetTypeSchema,
-  src: z13.string().min(1, "Asset src is required"),
-  description: z13.string().optional(),
-  spritesheet: z13.object({
-    columns: z13.number().int().positive(),
-    rows: z13.number().int().positive(),
-    frameCount: z13.number().int().positive().optional(),
-    frameWidth: z13.number().positive(),
-    frameHeight: z13.number().positive()
-  }).optional(),
-  videoMeta: z13.object({
-    duration: z13.number().positive("videoMeta.duration must be positive"),
-    fps: z13.number().positive("videoMeta.fps must be positive"),
-    width: z13.number().int().positive(),
-    height: z13.number().int().positive()
-  }).optional()
-});
-var CanvasSchema = z14.object({
-  width: z14.number().int().positive("Canvas width must be a positive integer"),
-  height: z14.number().int().positive("Canvas height must be a positive integer"),
-  fps: z14.number().int().positive("FPS must be a positive integer"),
-  background: z14.string().optional()
-});
-var AtelierDocumentSchema = z14.object({
-  version: z14.string().min(1, "Version is required"),
-  name: z14.string().min(1, "Animation name is required"),
-  description: z14.string().optional(),
-  tags: z14.array(z14.string()).optional(),
-  canvas: CanvasSchema,
-  variables: z14.record(z14.string(), VariableSchema).optional(),
-  assets: z14.record(z14.string(), AssetSchema).optional(),
-  presets: z14.record(z14.string(), PresetSchema).optional(),
-  layers: z14.array(LayerSchema),
-  states: z14.record(z14.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 validateVideoLayer(visual, videoMetaDuration) {
-  const errors = [];
-  if (!visual.assetId) {
-    errors.push({ path: "assetId", message: "assetId is required" });
-  }
-  const sourceOffset = visual.sourceOffset ?? 0;
-  if (visual.sourceEnd !== void 0) {
-    if (visual.sourceEnd <= sourceOffset) {
-      errors.push({
-        path: "sourceEnd",
-        message: `sourceEnd (${visual.sourceEnd}) must be greater than sourceOffset (${sourceOffset})`
-      });
-    }
-    if (videoMetaDuration !== void 0 && visual.sourceEnd > videoMetaDuration) {
-      errors.push({
-        path: "sourceEnd",
-        message: `sourceEnd (${visual.sourceEnd}) exceeds asset duration (${videoMetaDuration})`
-      });
-    }
-  }
-  if (videoMetaDuration !== void 0 && sourceOffset >= videoMetaDuration) {
-    errors.push({
-      path: "sourceOffset",
-      message: `sourceOffset (${sourceOffset}) is at or beyond asset duration (${videoMetaDuration})`
-    });
-  }
-  if (errors.length > 0) return { success: false, errors };
-  return { success: true, data: visual };
-}
-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);
-}
-
-// 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, writeFileSync } 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 or render as PNG"
-  ).option("-s, --state <name>", "State name (defaults to first state)").option(
-    "-f, --frame <number>",
-    "Frame number (defaults to 0)",
-    "0"
-  ).option(
-    "--format <type>",
-    "Output format: json | png (default: json)",
-    "json"
-  ).option("-o, --output <path>", "Output file path (default: stdout)").action(
-    async (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;
-      }
-      if (options.format !== "json" && options.format !== "png") {
-        console.error(`Unknown format: "${options.format}". Use json or png.`);
-        process.exit(1);
-        return;
-      }
-      try {
-        const resolved = resolveStill(
-          doc,
-          options.state,
-          frameNumber
-        );
-        if (options.format === "json") {
-          const json = JSON.stringify(resolved, null, 2);
-          if (options.output) {
-            writeFileSync(resolve3(options.output), json, "utf-8");
-          } else {
-            console.log(json);
-          }
-        } else {
-          let canvasMod;
-          try {
-            canvasMod = await import("canvas");
-          } catch {
-            console.error("PNG output requires the 'canvas' package. Install it: npm i canvas");
-            process.exit(1);
-            return;
-          }
-          const { renderFrame: renderFrame2 } = await import("./dist-M67UZGFQ.js");
-          const { createCanvas } = canvasMod;
-          const cvs = createCanvas(doc.canvas.width, doc.canvas.height);
-          const ctx = cvs.getContext("2d");
-          renderFrame2(ctx, resolved, doc);
-          const buffer = cvs.toBuffer("image/png");
-          if (options.output) {
-            writeFileSync(resolve3(options.output), buffer);
-          } else {
-            process.stdout.write(buffer);
-          }
-        }
-      } catch (err) {
-        console.error(
-          err.message
-        );
-        process.exit(1);
-      }
-    }
-  );
-}
-
-// src/commands/render-pipeline.ts
-import { spawn } from "child_process";
-async function checkFfmpeg() {
-  return new Promise((resolve9) => {
-    const proc = spawn("ffmpeg", ["-version"], { stdio: "pipe" });
-    proc.on("error", () => resolve9(false));
-    proc.on("close", (code) => resolve9(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((resolve9) => process.nextTick(resolve9));
-  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(
-          (resolve9) => ffmpeg.stdin.once("drain", resolve9)
-        );
-      }
-      frameIndex++;
-      onProgress?.({
-        frame: frameIndex,
-        totalFrames,
-        state: stateName,
-        percent: Math.round(frameIndex / totalFrames * 100)
-      });
-    }
-  }
-  ffmpeg.stdin.end();
-  const exitCode = await new Promise((resolve9) => {
-    ffmpeg.on("close", resolve9);
-  });
-  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);
-      }
-    }
-  );
-}
-
-// src/commands/export-svg.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve5 } from "path";
-
-// ../svg/dist/index.js
-function buildTransform(eff) {
-  const parts = [];
-  if (eff.x !== 0 || eff.y !== 0) {
-    parts.push(`translate(${eff.x}, ${eff.y})`);
-  }
-  const totalRotation = eff.rotation + eff.motionPathAngle;
-  if (totalRotation !== 0 || eff.scaleX !== 1 || eff.scaleY !== 1) {
-    const ax = eff.anchorX * eff.width;
-    const ay = eff.anchorY * eff.height;
-    if (ax !== 0 || ay !== 0) {
-      parts.push(`translate(${ax}, ${ay})`);
-    }
-    if (totalRotation !== 0) {
-      parts.push(`rotate(${totalRotation})`);
-    }
-    if (eff.scaleX !== 1 || eff.scaleY !== 1) {
-      parts.push(`scale(${eff.scaleX}, ${eff.scaleY})`);
-    }
-    if (ax !== 0 || ay !== 0) {
-      parts.push(`translate(${-ax}, ${-ay})`);
-    }
-  }
-  return parts.length > 0 ? parts.join(" ") : "";
-}
-function buildStyleAttrs(eff) {
-  const attrs = [];
-  if (eff.opacity < 1) {
-    attrs.push(`opacity="${eff.opacity}"`);
-  }
-  if (eff.blendMode !== "normal") {
-    attrs.push(`style="mix-blend-mode: ${eff.blendMode}"`);
-  }
-  return attrs.join(" ");
-}
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-var gradientIdCounter = 0;
-function resetGradientCounter() {
-  gradientIdCounter = 0;
-}
-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 buildGradientDef(fill, width, height) {
-  if (fill.type === "solid") {
-    return { defs: "", fillRef: colorToCSS(fill.color) };
-  }
-  if (fill.type === "linear-gradient") {
-    return buildLinearGradient(fill, width, height);
-  }
-  if (fill.type === "radial-gradient") {
-    return buildRadialGradient(fill, width, height);
-  }
-  return { defs: "", fillRef: "none" };
-}
-function buildLinearGradient(fill, _width, _height) {
-  const id = `grad-${++gradientIdCounter}`;
-  const rad = fill.angle * Math.PI / 180;
-  const cos = Math.cos(rad);
-  const sin = Math.sin(rad);
-  const x1 = 0.5 - cos * 0.5;
-  const y1 = 0.5 - sin * 0.5;
-  const x2 = 0.5 + cos * 0.5;
-  const y2 = 0.5 + sin * 0.5;
-  const stops = fill.stops.map(
-    (s) => `<stop offset="${s.offset}" stop-color="${colorToCSS(s.color)}" />`
-  ).join("");
-  const def = `<linearGradient id="${id}" x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}">${stops}</linearGradient>`;
-  return { defs: def, fillRef: `url(#${id})` };
-}
-function buildRadialGradient(fill, width, height) {
-  const id = `grad-${++gradientIdCounter}`;
-  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 stops = fill.stops.map(
-    (s) => `<stop offset="${s.offset}" stop-color="${colorToCSS(s.color)}" />`
-  ).join("");
-  const def = `<radialGradient id="${id}" cx="${cx}" cy="${cy}" r="${r}" gradientUnits="userSpaceOnUse">${stops}</radialGradient>`;
-  return { defs: def, fillRef: `url(#${id})` };
-}
-function renderShapeSVG(eff, visual) {
-  const { shape } = visual;
-  const defs = [];
-  let fillAttr = "none";
-  if (visual.fill) {
-    const gradResult = buildGradientDef(visual.fill, eff.width, eff.height);
-    if (gradResult.defs) defs.push(gradResult.defs);
-    fillAttr = gradResult.fillRef;
-  }
-  let strokeAttrs = "";
-  if (visual.stroke) {
-    strokeAttrs = buildStrokeAttrs(visual.stroke);
-  }
-  const element = buildShapeElement(shape, eff.width, eff.height, fillAttr, strokeAttrs);
-  return { elements: element, defs: defs.join("") };
-}
-function buildShapeElement(shape, width, height, fill, strokeAttrs) {
-  switch (shape.type) {
-    case "rect":
-      return buildRectElement(shape, width, height, fill, strokeAttrs);
-    case "ellipse":
-      return buildEllipseElement(width, height, fill, strokeAttrs);
-    case "path":
-      return buildPathElement(shape, fill, strokeAttrs);
-  }
-}
-function buildRectElement(shape, width, height, fill, strokeAttrs) {
-  let rx = "";
-  if (shape.cornerRadius) {
-    const r = typeof shape.cornerRadius === "number" ? shape.cornerRadius : shape.cornerRadius[0];
-    rx = ` rx="${r}" ry="${r}"`;
-  }
-  return `<rect width="${width}" height="${height}" fill="${fill}"${rx}${strokeAttrs ? " " + strokeAttrs : ""} />`;
-}
-function buildEllipseElement(width, height, fill, strokeAttrs) {
-  const cx = width / 2;
-  const cy = height / 2;
-  const rx = width / 2;
-  const ry = height / 2;
-  return `<ellipse cx="${cx}" cy="${cy}" rx="${rx}" ry="${ry}" fill="${fill}"${strokeAttrs ? " " + strokeAttrs : ""} />`;
-}
-function buildPathElement(shape, fill, strokeAttrs) {
-  if (shape.points.length < 2) return "";
-  const d = [];
-  d.push(`M ${shape.points[0].x} ${shape.points[0].y}`);
-  for (let i = 1; i < shape.points.length; i++) {
-    const prev = shape.points[i - 1];
-    const curr = shape.points[i];
-    if (prev.out && curr.in) {
-      d.push(`C ${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 {
-      d.push(`L ${curr.x} ${curr.y}`);
-    }
-  }
-  if (shape.closed) d.push("Z");
-  return `<path d="${d.join(" ")}" fill="${fill}"${strokeAttrs ? " " + strokeAttrs : ""} />`;
-}
-function buildStrokeAttrs(stroke) {
-  const parts = [];
-  parts.push(`stroke="${colorToCSS(stroke.color)}"`);
-  parts.push(`stroke-width="${stroke.width}"`);
-  if (stroke.lineCap) parts.push(`stroke-linecap="${stroke.lineCap}"`);
-  if (stroke.lineJoin) parts.push(`stroke-linejoin="${stroke.lineJoin}"`);
-  if (stroke.dash) parts.push(`stroke-dasharray="${stroke.dash.join(" ")}"`);
-  return parts.join(" ");
-}
-function renderTextSVG(eff, visual) {
-  const { style } = visual;
-  const attrs = [];
-  attrs.push(`font-family="${escapeXml(style.fontFamily)}"`);
-  attrs.push(`font-size="${style.fontSize}"`);
-  if (style.fontWeight && style.fontWeight !== "normal") {
-    attrs.push(`font-weight="${style.fontWeight}"`);
-  }
-  if (style.fontStyle && style.fontStyle !== "normal") {
-    attrs.push(`font-style="${style.fontStyle}"`);
-  }
-  attrs.push(`fill="${colorToCSS(style.color)}"`);
-  const align = style.textAlign ?? "left";
-  let textAnchor = "start";
-  let x = 0;
-  if (align === "center") {
-    textAnchor = "middle";
-    x = eff.width / 2;
-  } else if (align === "right") {
-    textAnchor = "end";
-    x = eff.width;
-  }
-  attrs.push(`text-anchor="${textAnchor}"`);
-  if (style.letterSpacing) {
-    attrs.push(`letter-spacing="${style.letterSpacing}"`);
-  }
-  attrs.push(`dominant-baseline="hanging"`);
-  return `<text x="${x}" y="0" ${attrs.join(" ")}>${escapeXml(visual.content)}</text>`;
-}
-var filterIdCounter = 0;
-function resetFilterCounter() {
-  filterIdCounter = 0;
-}
-function buildShadowFilter(eff) {
-  if (!eff.shadow) return null;
-  const id = `filter-${++filterIdCounter}`;
-  const { color, blur, offsetX, offsetY } = eff.shadow;
-  const def = [
-    `<filter id="${id}" x="-50%" y="-50%" width="200%" height="200%">`,
-    `<feDropShadow dx="${offsetX}" dy="${offsetY}" stdDeviation="${blur / 2}" flood-color="${color}" />`,
-    `</filter>`
-  ].join("");
-  return { defs: def, filterRef: `url(#${id})` };
-}
-function buildTintFilter(eff) {
-  if (!eff.tint || eff.tint.amount <= 0) return null;
-  const id = `filter-${++filterIdCounter}`;
-  const { color, amount } = eff.tint;
-  const def = [
-    `<filter id="${id}" x="0%" y="0%" width="100%" height="100%">`,
-    `<feFlood flood-color="${color}" flood-opacity="${amount}" result="tint" />`,
-    `<feBlend in="SourceGraphic" in2="tint" mode="multiply" />`,
-    `</filter>`
-  ].join("");
-  return { defs: def, filterRef: `url(#${id})` };
-}
-var clipIdCounter = 0;
-function resetClipCounter() {
-  clipIdCounter = 0;
-}
-function buildClipPathDef(shape, width, height) {
-  const id = `clip-${++clipIdCounter}`;
-  let pathContent = "";
-  switch (shape.type) {
-    case "rect":
-      if (shape.cornerRadius) {
-        const r = typeof shape.cornerRadius === "number" ? shape.cornerRadius : shape.cornerRadius[0];
-        pathContent = `<rect width="${width}" height="${height}" rx="${r}" ry="${r}" />`;
-      } else {
-        pathContent = `<rect width="${width}" height="${height}" />`;
-      }
-      break;
-    case "ellipse":
-      pathContent = `<ellipse cx="${width / 2}" cy="${height / 2}" rx="${width / 2}" ry="${height / 2}" />`;
-      break;
-    case "path": {
-      if (shape.points.length < 2) return { defs: "", clipRef: "" };
-      const d = [];
-      d.push(`M ${shape.points[0].x} ${shape.points[0].y}`);
-      for (let i = 1; i < shape.points.length; i++) {
-        const prev = shape.points[i - 1];
-        const curr = shape.points[i];
-        if (prev.out && curr.in) {
-          d.push(`C ${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 {
-          d.push(`L ${curr.x} ${curr.y}`);
-        }
-      }
-      if (shape.closed) d.push("Z");
-      pathContent = `<path d="${d.join(" ")}" />`;
-      break;
-    }
-  }
-  const def = `<clipPath id="${id}">${pathContent}</clipPath>`;
-  return { defs: def, clipRef: `url(#${id})` };
-}
-function renderFrameSVG(doc, stateOrFrame, frame, opts) {
-  resetGradientCounter();
-  resetFilterCounter();
-  resetClipCounter();
-  let resolved;
-  if (typeof stateOrFrame === "string") {
-    resolved = resolveFrame(doc, stateOrFrame, frame ?? 0);
-  } else {
-    resolved = stateOrFrame;
-  }
-  const { width, height } = doc.canvas;
-  const indent = opts?.indent ?? 2;
-  const pad = " ".repeat(indent);
-  const effLayers = resolved.layers.map(
-    (rl) => buildEffectiveLayer(rl, width, height)
-  );
-  const allDefs = [];
-  const layerElements = [];
-  for (let i = 0; i < effLayers.length; i++) {
-    const eff = effLayers[i];
-    const layer = resolved.layers[i].layer;
-    if (!eff.visible) continue;
-    if (eff.opacity <= 0) continue;
-    if (layer.visual.type === "image") {
-      const iv = eff.visual;
-      if (!iv.src && iv.assetId && doc.assets?.[iv.assetId]) {
-        eff.visual.src = doc.assets[iv.assetId].src;
-      }
-    }
-    const transform = buildTransform(eff);
-    const styleAttrs = buildStyleAttrs(eff);
-    const filterResult = buildShadowFilter(eff);
-    if (filterResult) allDefs.push(filterResult.defs);
-    const tintResult = buildTintFilter(eff);
-    if (tintResult) allDefs.push(tintResult.defs);
-    let clipAttr = "";
-    if (layer.clipPath) {
-      const clipResult = buildClipPathDef(layer.clipPath, eff.width, eff.height);
-      if (clipResult.defs) {
-        allDefs.push(clipResult.defs);
-        clipAttr = ` clip-path="${clipResult.clipRef}"`;
-      }
-    }
-    const gAttrs = [];
-    if (transform) gAttrs.push(`transform="${transform}"`);
-    if (styleAttrs) gAttrs.push(styleAttrs);
-    if (filterResult && tintResult) {
-      gAttrs.push(`filter="${filterResult.filterRef}"`);
-    } else if (filterResult) {
-      gAttrs.push(`filter="${filterResult.filterRef}"`);
-    } else if (tintResult) {
-      gAttrs.push(`filter="${tintResult.filterRef}"`);
-    }
-    if (clipAttr) gAttrs.push(clipAttr.trim());
-    let content = "";
-    let layerDefs = "";
-    switch (layer.visual.type) {
-      case "shape": {
-        const result = renderShapeSVG(eff, eff.visual);
-        content = result.elements;
-        layerDefs = result.defs;
-        break;
-      }
-      case "text":
-        content = renderTextSVG(eff, eff.visual);
-        break;
-      case "image": {
-        const iv = eff.visual;
-        if (iv.src) {
-          if (iv.spritesheet) {
-            const { columns, rows, frameWidth, frameHeight, frameCount } = iv.spritesheet;
-            const maxFrames = frameCount ?? columns * rows;
-            const idx = Math.max(0, Math.min(Math.floor(iv.frameIndex ?? 0), maxFrames - 1));
-            const col = idx % columns;
-            const row = Math.floor(idx / columns);
-            const sx = col * frameWidth;
-            const sy = row * frameHeight;
-            const imgW = columns * frameWidth;
-            const imgH = rows * frameHeight;
-            content = `<svg viewBox="${sx} ${sy} ${frameWidth} ${frameHeight}" width="${eff.width}" height="${eff.height}"><image href="${escapeXml(iv.src)}" width="${imgW}" height="${imgH}" /></svg>`;
-          } else if (iv.sourceRect) {
-            const sr = iv.sourceRect;
-            content = `<svg viewBox="${sr.x} ${sr.y} ${sr.width} ${sr.height}" width="${eff.width}" height="${eff.height}"><image href="${escapeXml(iv.src)}" width="${eff.width}" height="${eff.height}" /></svg>`;
-          } else {
-            content = `<image href="${escapeXml(iv.src)}" width="${eff.width}" height="${eff.height}" />`;
-          }
-        }
-        break;
-      }
-      case "group":
-        break;
-      case "ref": {
-        const refVisual = eff.visual;
-        const refContent = renderRefSVG(eff, refVisual, doc, opts);
-        content = refContent;
-        break;
-      }
-    }
-    if (layerDefs) allDefs.push(layerDefs);
-    if (content) {
-      const gOpen = gAttrs.length > 0 ? `<g ${gAttrs.join(" ")}>` : "<g>";
-      layerElements.push(`${pad}${gOpen}${content}</g>`);
-    }
-  }
-  const lines = [];
-  if (opts?.xmlDeclaration) {
-    lines.push('<?xml version="1.0" encoding="UTF-8"?>');
-  }
-  const viewBox = opts?.viewBox !== false ? ` viewBox="0 0 ${width} ${height}"` : "";
-  const bg = doc.canvas.background;
-  lines.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}"${viewBox}>`);
-  if (allDefs.length > 0) {
-    lines.push(`${pad}<defs>`);
-    for (const def of allDefs) {
-      lines.push(`${pad}${pad}${def}`);
-    }
-    lines.push(`${pad}</defs>`);
-  }
-  if (bg && bg !== "transparent") {
-    lines.push(`${pad}<rect width="${width}" height="${height}" fill="${bg}" />`);
-  }
-  lines.push(...layerElements);
-  lines.push("</svg>");
-  return lines.join("\n");
-}
-function renderRefSVG(eff, visual, _parentDoc, opts, _depth, _visitedRefs) {
-  const resolver = opts?.documentResolver;
-  if (!resolver) {
-    return `<rect width="${eff.width}" height="${eff.height}" fill="none" stroke="#999" stroke-dasharray="4 2" />`;
-  }
-  const depth = _depth ?? 0;
-  const maxDepth = opts?.maxRefDepth ?? 4;
-  if (depth >= maxDepth) {
-    return `<rect width="${eff.width}" height="${eff.height}" fill="none" stroke="#c33" stroke-dasharray="4 2" /><text x="${eff.width / 2}" y="${eff.height / 2}" text-anchor="middle" dominant-baseline="middle" fill="#c33" font-size="12">MAX DEPTH</text>`;
-  }
-  const visitedRefs = _visitedRefs ?? /* @__PURE__ */ new Set();
-  if (visitedRefs.has(visual.src)) {
-    return `<rect width="${eff.width}" height="${eff.height}" fill="none" stroke="#c33" stroke-dasharray="4 2" /><text x="${eff.width / 2}" y="${eff.height / 2}" text-anchor="middle" dominant-baseline="middle" fill="#c33" font-size="12">CYCLE</text>`;
-  }
-  const subDoc = resolver(visual.src);
-  if (!subDoc) {
-    return `<rect width="${eff.width}" height="${eff.height}" fill="none" stroke="#999" stroke-dasharray="4 2" /><text x="${eff.width / 2}" y="${eff.height / 2}" text-anchor="middle" dominant-baseline="middle" fill="#999" font-size="12">NOT FOUND</text>`;
-  }
-  const stateNames = Object.keys(subDoc.states);
-  if (stateNames.length === 0) {
-    return `<rect width="${eff.width}" height="${eff.height}" fill="none" stroke="#999" stroke-dasharray="4 2" />`;
-  }
-  const stateName = visual.state ?? stateNames[0];
-  const stateObj = subDoc.states[stateName];
-  if (!stateObj) {
-    return `<rect width="${eff.width}" height="${eff.height}" fill="none" stroke="#999" stroke-dasharray="4 2" />`;
-  }
-  const maxFrame = Math.max(0, stateObj.duration - 1);
-  const frame = Math.min(visual.frame ?? 0, maxFrame);
-  visitedRefs.add(visual.src);
-  const subW = subDoc.canvas.width;
-  const subH = subDoc.canvas.height;
-  const resolved = resolveFrame(subDoc, stateName, frame);
-  const subParts = [];
-  for (const rl of resolved.layers) {
-    const subEff = buildEffectiveLayer(rl, subW, subH);
-    if (!subEff.visible || subEff.opacity <= 0) continue;
-    if (rl.layer.visual.type === "image") {
-      const iv = subEff.visual;
-      if (!iv.src && iv.assetId && subDoc.assets?.[iv.assetId]) {
-        iv.src = subDoc.assets[iv.assetId].src;
-      }
-    }
-    const transform = buildTransform(subEff);
-    const styleAttrs = buildStyleAttrs(subEff);
-    const gAttrs = [];
-    if (transform) gAttrs.push(`transform="${transform}"`);
-    if (styleAttrs) gAttrs.push(styleAttrs);
-    let childContent = "";
-    switch (rl.layer.visual.type) {
-      case "shape": {
-        const result = renderShapeSVG(subEff, subEff.visual);
-        childContent = result.elements;
-        break;
-      }
-      case "text":
-        childContent = renderTextSVG(subEff, subEff.visual);
-        break;
-      case "image": {
-        const iv = subEff.visual;
-        if (iv.src) {
-          childContent = `<image href="${escapeXml(iv.src)}" width="${subEff.width}" height="${subEff.height}" />`;
-        }
-        break;
-      }
-      case "ref": {
-        const refV = subEff.visual;
-        childContent = renderRefSVG(subEff, refV, subDoc, opts, depth + 1, visitedRefs);
-        break;
-      }
-    }
-    if (childContent) {
-      const gOpen = gAttrs.length > 0 ? `<g ${gAttrs.join(" ")}>` : "<g>";
-      subParts.push(`${gOpen}${childContent}</g>`);
-    }
-  }
-  visitedRefs.delete(visual.src);
-  return `<svg x="0" y="0" width="${eff.width}" height="${eff.height}" viewBox="0 0 ${subW} ${subH}">${subParts.join("")}</svg>`;
-}
-
-// src/commands/export-svg.ts
-function readAndParse4(file) {
-  const absPath = resolve5(file);
-  let content;
-  try {
-    content = readFileSync5(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 exportSvgCommand(program) {
-  program.command("export-svg <file>").description("Export a frame as SVG").option("-s, --state <name>", "State name (defaults to first state)").option("-f, --frame <number>", "Frame number (defaults to 0)", "0").option("-o, --output <path>", "Output file path (default: stdout)").option("--xml-declaration", "Include XML declaration").action(
-    (file, options) => {
-      const doc = readAndParse4(file);
-      const frameNumber = parseInt(options.frame, 10);
-      if (isNaN(frameNumber) || frameNumber < 0) {
-        console.error(`Invalid frame number: ${options.frame}`);
-        process.exit(1);
-        return;
-      }
-      const stateNames = Object.keys(doc.states);
-      if (stateNames.length === 0) {
-        console.error("Document has no states");
-        process.exit(1);
-        return;
-      }
-      const stateName = options.state ?? stateNames[0];
-      if (!doc.states[stateName]) {
-        console.error(`State "${stateName}" not found. Available: ${stateNames.join(", ")}`);
-        process.exit(1);
-        return;
-      }
-      try {
-        const svg = renderFrameSVG(doc, stateName, frameNumber, {
-          xmlDeclaration: options.xmlDeclaration
-        });
-        if (options.output) {
-          writeFileSync2(resolve5(options.output), svg, "utf-8");
-        } else {
-          console.log(svg);
-        }
-      } catch (err) {
-        console.error(err.message);
-        process.exit(1);
-      }
-    }
-  );
-}
-
-// src/commands/export-lottie.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "fs";
-import { resolve as resolve6 } from "path";
-
-// ../lottie/dist/index.js
-function colorToLottie(color) {
-  if (typeof color === "string") {
-    return hexToLottie(color);
-  }
-  if ("r" in color) {
-    const c = color;
-    return [c.r / 255, c.g / 255, c.b / 255, c.a];
-  }
-  if ("h" in color) {
-    const c = color;
-    const rgb = hslToRgb(c.h, c.s, c.l);
-    return [rgb[0] / 255, rgb[1] / 255, rgb[2] / 255, c.a];
-  }
-  return [0, 0, 0, 1];
-}
-function hexToLottie(hex) {
-  const clean = hex.replace("#", "");
-  if (clean.length === 3 || clean.length === 4) {
-    const r2 = parseInt(clean[0] + clean[0], 16) / 255;
-    const g2 = parseInt(clean[1] + clean[1], 16) / 255;
-    const b2 = parseInt(clean[2] + clean[2], 16) / 255;
-    const a2 = clean.length === 4 ? parseInt(clean[3] + clean[3], 16) / 255 : 1;
-    return [r2, g2, b2, a2];
-  }
-  const r = parseInt(clean.slice(0, 2), 16) / 255;
-  const g = parseInt(clean.slice(2, 4), 16) / 255;
-  const b = parseInt(clean.slice(4, 6), 16) / 255;
-  const a = clean.length === 8 ? parseInt(clean.slice(6, 8), 16) / 255 : 1;
-  return [r, g, b, a];
-}
-function hslToRgb(h, s, l) {
-  s = s / 100;
-  l = l / 100;
-  const a = s * Math.min(l, 1 - l);
-  const f = (n) => {
-    const k = (n + h / 30) % 12;
-    return l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
-  };
-  return [Math.round(f(0) * 255), Math.round(f(8) * 255), Math.round(f(4) * 255)];
-}
-function mapShapeVisual(visual, width, height) {
-  const items = [];
-  switch (visual.shape.type) {
-    case "rect":
-      items.push({
-        ty: "rc",
-        nm: "Rectangle",
-        d: 1,
-        s: { a: 0, k: [width, height] },
-        p: { a: 0, k: [width / 2, height / 2] },
-        r: { a: 0, k: typeof visual.shape.cornerRadius === "number" ? visual.shape.cornerRadius : 0 }
-      });
-      break;
-    case "ellipse":
-      items.push({
-        ty: "el",
-        nm: "Ellipse",
-        d: 1,
-        s: { a: 0, k: [width, height] },
-        p: { a: 0, k: [width / 2, height / 2] }
-      });
-      break;
-    case "path": {
-      const vertices = visual.shape.points.map((p) => [p.x, p.y]);
-      const inTangents = visual.shape.points.map((p) => p.in ? [p.in.x, p.in.y] : [0, 0]);
-      const outTangents = visual.shape.points.map((p) => p.out ? [p.out.x, p.out.y] : [0, 0]);
-      items.push({
-        ty: "sh",
-        nm: "Path",
-        ks: {
-          a: 0,
-          k: {
-            c: visual.shape.closed ?? false,
-            v: vertices,
-            i: inTangents,
-            o: outTangents
-          }
-        }
-      });
-      break;
-    }
-  }
-  if (visual.fill) {
-    items.push(mapFill(visual.fill, width, height));
-  }
-  if (visual.stroke) {
-    items.push(mapStroke(visual.stroke));
-  }
-  return items;
-}
-function mapFill(fill, _width, _height) {
-  if (fill.type === "solid") {
-    const color = colorToLottie(fill.color);
-    return {
-      ty: "fl",
-      nm: "Fill",
-      c: { a: 0, k: color.slice(0, 3) },
-      o: { a: 0, k: (color[3] ?? 1) * 100 },
-      r: 1
-    };
-  }
-  if (fill.type === "linear-gradient") {
-    const stops = [];
-    for (const stop of fill.stops) {
-      const c = colorToLottie(stop.color);
-      stops.push(stop.offset, c[0], c[1], c[2]);
-    }
-    return {
-      ty: "gf",
-      nm: "Gradient Fill",
-      t: 1,
-      // linear
-      s: { a: 0, k: [0, 0] },
-      e: { a: 0, k: [100, 0] },
-      g: { p: fill.stops.length, k: { a: 0, k: stops } },
-      r: 1,
-      o: { a: 0, k: 100 }
-    };
-  }
-  if (fill.type === "radial-gradient") {
-    const stops = [];
-    for (const stop of fill.stops) {
-      const c = colorToLottie(stop.color);
-      stops.push(stop.offset, c[0], c[1], c[2]);
-    }
-    return {
-      ty: "gf",
-      nm: "Gradient Fill",
-      t: 2,
-      // radial
-      s: { a: 0, k: [50, 50] },
-      e: { a: 0, k: [100, 50] },
-      g: { p: fill.stops.length, k: { a: 0, k: stops } },
-      r: 1,
-      o: { a: 0, k: 100 }
-    };
-  }
-  return { ty: "fl", nm: "Fill", c: { a: 0, k: [0, 0, 0] }, o: { a: 0, k: 100 }, r: 1 };
-}
-function mapStroke(stroke) {
-  const color = colorToLottie(stroke.color);
-  return {
-    ty: "st",
-    nm: "Stroke",
-    c: { a: 0, k: color.slice(0, 3) },
-    o: { a: 0, k: (color[3] ?? 1) * 100 },
-    w: { a: 0, k: stroke.width },
-    lc: stroke.lineCap === "round" ? 2 : stroke.lineCap === "square" ? 3 : 1,
-    lj: stroke.lineJoin === "round" ? 2 : stroke.lineJoin === "bevel" ? 3 : 1
-  };
-}
-function mapEasing(easing) {
-  if (!easing) return linearEasing();
-  if (typeof easing === "string") {
-    switch (easing) {
-      case "ease-in":
-        return bezierEasing(0.42, 0, 1, 1);
-      case "ease-out":
-        return bezierEasing(0, 0, 0.58, 1);
-      case "ease-in-out":
-        return bezierEasing(0.42, 0, 0.58, 1);
-      default:
-        return linearEasing();
-    }
-  }
-  switch (easing.type) {
-    case "linear":
-      return linearEasing();
-    case "cubic-bezier":
-      return bezierEasing(easing.x1, easing.y1, easing.x2, easing.y2);
-    case "spring":
-      return bezierEasing(0.25, 0.1, 0.25, 1);
-    case "step":
-      return { h: 1 };
-    default:
-      return linearEasing();
-  }
-}
-function linearEasing() {
-  return {
-    i: { x: [0.833], y: [0.833] },
-    o: { x: [0.167], y: [0.167] }
-  };
-}
-function bezierEasing(x1, y1, x2, y2) {
-  return {
-    i: { x: [x2], y: [y2] },
-    o: { x: [x1], y: [y1] }
-  };
-}
-function isLossyEasing(easing) {
-  if (!easing || typeof easing === "string") return null;
-  if (easing.type === "spring") return "Spring easing approximated as cubic-bezier";
-  if (easing.type === "step") return "Step easing mapped to hold keyframes";
-  return null;
-}
-function mapDeltasToAnimated(deltas, property, warnings) {
-  if (deltas.length === 0) {
-    return { a: 0, k: 0 };
-  }
-  for (const d of deltas) {
-    const lossyMsg = isLossyEasing(d.easing);
-    if (lossyMsg) warnings.push(`${property}: ${lossyMsg}`);
-  }
-  for (const d of deltas) {
-    if (isExpression(d.from) || isExpression(d.to)) {
-      warnings.push(`${property}: Expression values not supported in Lottie, using static values`);
-      return { a: 0, k: typeof d.from === "number" ? d.from : 0 };
-    }
-  }
-  if (deltas.length === 1) {
-    const d = deltas[0];
-    const fromVal = resolveValue(d.from, property);
-    const toVal = resolveValue(d.to, property);
-    if (fromVal === toVal) {
-      return { a: 0, k: fromVal };
-    }
-    const easing = mapEasing(d.easing);
-    const kfs2 = [];
-    if ("h" in easing) {
-      kfs2.push({ t: d.range[0], s: [fromVal], h: 1 });
-      kfs2.push({ t: d.range[1], s: [toVal] });
-    } else {
-      kfs2.push({ t: d.range[0], s: [fromVal], e: [toVal], i: easing.i, o: easing.o });
-      kfs2.push({ t: d.range[1], s: [toVal] });
-    }
-    return { a: 1, k: kfs2 };
-  }
-  const sorted = [...deltas].sort((a, b) => a.range[0] - b.range[0]);
-  const kfs = [];
-  for (const d of sorted) {
-    const fromVal = resolveValue(d.from, property);
-    const toVal = resolveValue(d.to, property);
-    const easing = mapEasing(d.easing);
-    if ("h" in easing) {
-      kfs.push({ t: d.range[0], s: [fromVal], h: 1 });
-    } else {
-      kfs.push({ t: d.range[0], s: [fromVal], e: [toVal], i: easing.i, o: easing.o });
-    }
-  }
-  const last = sorted[sorted.length - 1];
-  kfs.push({ t: last.range[1], s: [resolveValue(last.to, property)] });
-  return { a: 1, k: kfs };
-}
-function mapPositionDeltas(xDeltas, yDeltas, baseX, baseY, warnings) {
-  const hasXAnim = xDeltas.length > 0;
-  const hasYAnim = yDeltas.length > 0;
-  if (!hasXAnim && !hasYAnim) {
-    return { a: 0, k: [baseX, baseY, 0] };
-  }
-  const frames = /* @__PURE__ */ new Set();
-  for (const d of [...xDeltas, ...yDeltas]) {
-    frames.add(d.range[0]);
-    frames.add(d.range[1]);
-  }
-  const sortedFrames = [...frames].sort((a, b) => a - b);
-  if (sortedFrames.length < 2) {
-    return { a: 0, k: [baseX, baseY, 0] };
-  }
-  const kfs = [];
-  for (let i = 0; i < sortedFrames.length; i++) {
-    const f = sortedFrames[i];
-    const x = resolveAtFrame(xDeltas, f, baseX);
-    const y = resolveAtFrame(yDeltas, f, baseY);
-    if (i < sortedFrames.length - 1) {
-      const nextF = sortedFrames[i + 1];
-      const nextX = resolveAtFrame(xDeltas, nextF, baseX);
-      const nextY = resolveAtFrame(yDeltas, nextF, baseY);
-      const activeX = xDeltas.find((d) => d.range[0] <= f && d.range[1] >= f);
-      const activeY = yDeltas.find((d) => d.range[0] <= f && d.range[1] >= f);
-      const easing = mapEasing(activeX?.easing ?? activeY?.easing);
-      if ("h" in easing) {
-        kfs.push({ t: f, s: [x, y, 0], h: 1 });
-      } else {
-        kfs.push({ t: f, s: [x, y, 0], e: [nextX, nextY, 0], i: easing.i, o: easing.o });
-      }
-    } else {
-      kfs.push({ t: f, s: [x, y, 0] });
-    }
-  }
-  for (const d of [...xDeltas, ...yDeltas]) {
-    const msg = isLossyEasing(d.easing);
-    if (msg) warnings.push(`position: ${msg}`);
-  }
-  return { a: 1, k: kfs };
-}
-function resolveAtFrame(deltas, frame, base) {
-  for (const d of deltas) {
-    if (frame >= d.range[0] && frame <= d.range[1]) {
-      const from = typeof d.from === "number" ? d.from : base;
-      const to = typeof d.to === "number" ? d.to : base;
-      const progress = d.range[0] === d.range[1] ? 1 : (frame - d.range[0]) / (d.range[1] - d.range[0]);
-      return from + (to - from) * progress;
-    }
-  }
-  let lastCompleted;
-  for (const d of deltas) {
-    if (frame > d.range[1]) {
-      if (!lastCompleted || d.range[1] > lastCompleted.range[1]) {
-        lastCompleted = d;
-      }
-    }
-  }
-  if (lastCompleted) return typeof lastCompleted.to === "number" ? lastCompleted.to : base;
-  return base;
-}
-function resolveValue(val, _property) {
-  if (typeof val === "number") return val;
-  if (typeof val === "string" && val.startsWith("#")) {
-    return 0;
-  }
-  return 0;
-}
-function isExpression(val) {
-  return typeof val === "object" && val !== null && "expr" in val;
-}
-function toNum(v) {
-  return typeof v === "number" ? v : 0;
-}
-function mapLayers(doc, state, warnings) {
-  const layerIndexMap = /* @__PURE__ */ new Map();
-  doc.layers.forEach((l, i) => layerIndexMap.set(l.id, i));
-  return doc.layers.map((layer, index) => {
-    const deltas = state.deltas.filter((d) => d.layer === layer.id);
-    return mapLayer(layer, index, deltas, layerIndexMap, doc, warnings);
-  });
-}
-function mapLayer(layer, index, deltas, layerIndexMap, doc, warnings) {
-  const duration = getMaxFrame(deltas, doc);
-  const base = {
-    ty: getLayerType(layer),
-    nm: layer.id,
-    ind: index,
-    ip: 0,
-    op: duration,
-    st: 0,
-    ks: buildTransform2(layer, deltas, warnings)
-  };
-  if (layer.parentId) {
-    const parentIdx = layerIndexMap.get(layer.parentId);
-    if (parentIdx !== void 0) {
-      base.parent = parentIdx;
-    }
-  }
-  if (layer.blendMode) {
-    base.bm = mapBlendMode(layer.blendMode);
-  }
-  if (layer.visual.type === "shape") {
-    base.shapes = mapShapeVisual(layer.visual, toNum(layer.bounds.width), toNum(layer.bounds.height));
-  }
-  if (layer.visual.type === "text") {
-    const color = colorToLottie(layer.visual.style.color);
-    base.t = {
-      d: {
-        k: [{
-          s: {
-            s: layer.visual.style.fontSize,
-            f: layer.visual.style.fontFamily,
-            t: layer.visual.content,
-            fc: color.slice(0, 3),
-            j: layer.visual.style.textAlign === "center" ? 1 : layer.visual.style.textAlign === "right" ? 2 : 0
-          },
-          t: 0
-        }]
-      }
-    };
-  }
-  if (layer.visual.type === "image") {
-    base.refId = layer.visual.assetId;
-    base.w = toNum(layer.bounds.width);
-    base.h = toNum(layer.bounds.height);
-    if (layer.visual.spritesheet) {
-      warnings.push(`Layer "${layer.id}": Spritesheet animation not supported in Lottie export`);
-    }
-    if (layer.visual.sourceRect) {
-      warnings.push(`Layer "${layer.id}": sourceRect cropping not supported in Lottie export`);
-    }
-  }
-  if (layer.tint && layer.tint.amount > 0) {
-    warnings.push(`Layer "${layer.id}": Tint effect not supported in Lottie export`);
-  }
-  return base;
-}
-function getLayerType(layer) {
-  switch (layer.visual.type) {
-    case "shape":
-      return 4;
-    case "text":
-      return 5;
-    case "image":
-      return 2;
-    case "group":
-      return 3;
-    // null layer
-    case "ref":
-      return 0;
-    // precomp
-    default:
-      return 4;
-  }
-}
-function buildTransform2(layer, deltas, warnings) {
-  const byProp = /* @__PURE__ */ new Map();
-  for (const d of deltas) {
-    if (!byProp.has(d.property)) byProp.set(d.property, []);
-    byProp.get(d.property).push(d);
-  }
-  const xDeltas = byProp.get("frame.x") ?? [];
-  const yDeltas = byProp.get("frame.y") ?? [];
-  const opacityDeltas = byProp.get("opacity") ?? [];
-  const rotationDeltas = byProp.get("rotation") ?? [];
-  const scaleXDeltas = byProp.get("scale.x") ?? [];
-  const scaleYDeltas = byProp.get("scale.y") ?? [];
-  const position = mapPositionDeltas(
-    xDeltas,
-    yDeltas,
-    typeof layer.frame.x === "number" ? layer.frame.x : 0,
-    typeof layer.frame.y === "number" ? layer.frame.y : 0,
-    warnings
-  );
-  let opacity;
-  if (opacityDeltas.length > 0) {
-    const raw = mapDeltasToAnimated(opacityDeltas, "opacity", warnings);
-    if (raw.a === 0) {
-      opacity = { a: 0, k: raw.k * 100 };
-    } else {
-      const kfs = raw.k.map((kf) => ({
-        ...kf,
-        s: [kf.s[0] * 100],
-        e: kf.e ? [kf.e[0] * 100] : void 0
-      }));
-      opacity = { a: 1, k: kfs };
-    }
-  } else {
-    opacity = { a: 0, k: (layer.opacity ?? 1) * 100 };
-  }
-  const rotation = rotationDeltas.length > 0 ? mapDeltasToAnimated(rotationDeltas, "rotation", warnings) : { a: 0, k: layer.rotation ?? 0 };
-  const baseScaleX = (layer.scale?.x ?? 1) * 100;
-  const baseScaleY = (layer.scale?.y ?? 1) * 100;
-  let scale;
-  if (scaleXDeltas.length > 0 || scaleYDeltas.length > 0) {
-    scale = { a: 0, k: [baseScaleX, baseScaleY, 100] };
-    if (scaleXDeltas.length > 0 || scaleYDeltas.length > 0) {
-      warnings.push("Scale animation partially mapped to Lottie");
-    }
-  } else {
-    scale = { a: 0, k: [baseScaleX, baseScaleY, 100] };
-  }
-  const ax = (layer.anchorPoint?.x ?? 0) * toNum(layer.bounds.width);
-  const ay = (layer.anchorPoint?.y ?? 0) * toNum(layer.bounds.height);
-  return {
-    o: opacity,
-    r: rotation,
-    p: position,
-    a: { a: 0, k: [ax, ay, 0] },
-    s: scale
-  };
-}
-function getMaxFrame(deltas, doc) {
-  let max = 0;
-  for (const state of Object.values(doc.states)) {
-    if (state.duration > max) max = state.duration;
-  }
-  for (const d of deltas) {
-    if (d.range[1] > max) max = d.range[1];
-  }
-  return max || 60;
-}
-function mapBlendMode(mode) {
-  const map = {
-    normal: 0,
-    multiply: 1,
-    screen: 2,
-    overlay: 3,
-    darken: 4,
-    lighten: 5,
-    "color-dodge": 6,
-    "color-burn": 7,
-    "hard-light": 8,
-    "soft-light": 9,
-    difference: 10,
-    exclusion: 11,
-    hue: 12,
-    saturation: 13,
-    color: 14,
-    luminosity: 15
-  };
-  return map[mode] ?? 0;
-}
-function collectUnsupportedWarnings(doc, state) {
-  const warnings = [];
-  if (state.audio) {
-    warnings.push("Audio tracks are not supported in Lottie format and will be dropped");
-  }
-  for (const delta of state.deltas) {
-    if (isExpression2(delta.from) || isExpression2(delta.to)) {
-      warnings.push(`Expression values on "${delta.layer}.${delta.property}" not supported in Lottie`);
-    }
-  }
-  for (const layer of doc.layers) {
-    if (layer.shadow) {
-      warnings.push(`Shadow on layer "${layer.id}" is not supported in base Lottie format`);
-    }
-  }
-  for (const layer of doc.layers) {
-    if (layer.motionPath) {
-      warnings.push(`Motion path on layer "${layer.id}" is not directly mappable to Lottie`);
-    }
-  }
-  for (const layer of doc.layers) {
-    if (layer.clipPath) {
-      warnings.push(`Clip path on layer "${layer.id}" mapped as Lottie mask (partial support)`);
-    }
-  }
-  if (Object.keys(doc.states).length > 1) {
-    warnings.push("Multiple states flattened to single timeline in Lottie export");
-  }
-  return warnings;
-}
-function isExpression2(val) {
-  return typeof val === "object" && val !== null && "expr" in val;
-}
-function exportToLottie(doc, opts) {
-  const stateNames = Object.keys(doc.states);
-  if (stateNames.length === 0) {
-    throw new Error("Document has no states to export");
-  }
-  const stateName = opts?.state ?? stateNames[0];
-  const state = doc.states[stateName];
-  if (!state) {
-    throw new Error(`State "${stateName}" not found`);
-  }
-  const warnings = [];
-  warnings.push(...collectUnsupportedWarnings(doc, state));
-  const layers = mapLayers(doc, state, warnings);
-  const assets = [];
-  if (doc.assets) {
-    for (const [id, asset] of Object.entries(doc.assets)) {
-      if (asset.type === "image") {
-        assets.push({
-          id,
-          w: 100,
-          h: 100,
-          p: asset.src,
-          e: 0
-        });
-      }
-    }
-  }
-  const json = {
-    v: "5.7.4",
-    fr: doc.canvas.fps,
-    ip: 0,
-    op: state.duration,
-    w: doc.canvas.width,
-    h: doc.canvas.height,
-    nm: doc.name,
-    layers,
-    ...assets.length > 0 ? { assets } : {}
-  };
-  const uniqueWarnings = [...new Set(warnings)];
-  return { json, warnings: uniqueWarnings };
-}
-
-// src/commands/export-lottie.ts
-function readAndParse5(file) {
-  const absPath = resolve6(file);
-  let content;
-  try {
-    content = readFileSync6(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 exportLottieCommand(program) {
-  program.command("export-lottie <file>").description("Export a document to Lottie JSON format").option("-s, --state <name>", "State name (defaults to first state)").option("-o, --output <path>", "Output file path (default: stdout)").action(
-    (file, options) => {
-      const doc = readAndParse5(file);
-      try {
-        const { json, warnings } = exportToLottie(doc, {
-          state: options.state
-        });
-        for (const warning of warnings) {
-          console.error(`Warning: ${warning}`);
-        }
-        const output = JSON.stringify(json, null, 2);
-        if (options.output) {
-          writeFileSync3(resolve6(options.output), output, "utf-8");
-        } else {
-          console.log(output);
-        }
-      } catch (err) {
-        console.error(err.message);
-        process.exit(1);
-      }
-    }
-  );
-}
-
-// src/commands/assets.ts
-import { readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve7 } from "path";
-function getAssets(doc) {
-  const assets = doc.assets ?? {};
-  return Object.entries(assets).map(([assetId, asset]) => {
-    const usedByLayers = doc.layers.filter((l) => l.visual.type === "image" && l.visual.assetId === assetId).map((l) => l.id);
-    const usedByStates = Object.entries(doc.states).filter(([, state]) => state.audio?.src === assetId).map(([name]) => name);
-    return {
-      assetId,
-      type: asset.type,
-      src: asset.src,
-      description: asset.description,
-      usedByLayers,
-      usedByStates
-    };
-  });
-}
-function formatAssets(assets) {
-  if (assets.length === 0) return "No assets registered.";
-  const lines = [`Assets: ${assets.length}`];
-  for (const a of assets) {
-    const desc = a.description ? ` \u2014 ${a.description}` : "";
-    lines.push(`  - ${a.assetId} (${a.type}): ${a.src}${desc}`);
-    if (a.usedByLayers.length > 0) {
-      lines.push(`    Layers: ${a.usedByLayers.join(", ")}`);
-    }
-    if (a.usedByStates.length > 0) {
-      lines.push(`    States: ${a.usedByStates.join(", ")}`);
-    }
-  }
-  return lines.join("\n");
-}
-function readAndParse6(file) {
-  const absPath = resolve7(file);
-  let content;
-  try {
-    content = readFileSync7(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 assetsCommand(program) {
-  program.command("assets <file>").description("List all assets in an .atelier file with usage info").action((file) => {
-    const doc = readAndParse6(file);
-    const assets = getAssets(doc);
-    console.log(formatAssets(assets));
-  });
-}
-
-// src/commands/variables.ts
-import { readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve8 } from "path";
-function getVariables(doc) {
-  const variables = doc.variables ?? {};
-  const referenced = findTemplateVariables(doc);
-  const entries = Object.entries(variables).map(([name, variable]) => ({
-    name,
-    type: variable.type,
-    description: variable.description,
-    default: variable.default,
-    referenced: referenced.includes(name)
-  }));
-  const undeclared = referenced.filter((r) => !variables[r]);
-  return { variables: entries, undeclared };
-}
-function formatVariables(info) {
-  if (info.variables.length === 0 && info.undeclared.length === 0) return "No variables declared or referenced.";
-  const lines = [];
-  if (info.variables.length > 0) {
-    lines.push(`Variables: ${info.variables.length}`);
-    for (const v of info.variables) {
-      const desc = v.description ? ` \u2014 ${v.description}` : "";
-      const def = v.default !== void 0 ? ` [default: ${JSON.stringify(v.default)}]` : "";
-      const ref = v.referenced ? "" : " (unused)";
-      lines.push(`  - {{${v.name}}} (${v.type})${def}${desc}${ref}`);
-    }
-  }
-  if (info.undeclared.length > 0) {
-    lines.push(`Undeclared references: ${info.undeclared.length}`);
-    for (const name of info.undeclared) {
-      lines.push(`  - {{${name}}} (not declared in variables)`);
-    }
-  }
-  return lines.join("\n");
-}
-function readAndParse7(file) {
-  const absPath = resolve8(file);
-  let content;
-  try {
-    content = readFileSync8(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 variablesCommand(program) {
-  program.command("variables <file>").description("List all variables in an .atelier file with usage info").action((file) => {
-    const doc = readAndParse7(file);
-    const info = getVariables(doc);
-    console.log(formatVariables(info));
-  });
-}
-
-export {
-  validateVideoLayer,
-  parseAtelier,
-  validateFile,
-  validateCommand,
-  getInfo,
-  infoCommand,
-  resolveStill,
-  stillCommand,
-  checkFfmpeg,
-  buildFfmpegArgs,
-  renderDocument,
-  renderCommand,
-  exportSvgCommand,
-  exportLottieCommand,
-  getAssets,
-  assetsCommand,
-  getVariables,
-  variablesCommand
-};
-//# sourceMappingURL=chunk-JV7RGETS.js.map