@a-company/atelier 0.29.0 → 0.37.0

package/dist/chunk-5QQESXI6.js

@@ -0,0 +1,4432 @@
+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 { z as z15 } 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)
+});
+var SilencePolicySchema = z15.object({
+  noise: z15.string().optional(),
+  min_silence: z15.number().nonnegative().optional(),
+  default_padding_pre: z15.number().nonnegative().optional(),
+  default_padding_post: z15.number().nonnegative().optional(),
+  match_tolerance: z15.number().nonnegative().optional()
+}).strict();
+var CaptionStyleSchema = z15.object({
+  font_family: z15.string().optional(),
+  font_size: z15.number().positive().optional(),
+  font_weight: z15.union([z15.literal("normal"), z15.literal("bold"), z15.number()]).optional(),
+  text_align: z15.enum(["left", "center", "right"]).optional(),
+  color: z15.string().optional(),
+  y_ratio: z15.number().min(0).max(1).optional(),
+  width_ratio: z15.number().min(0).max(1).optional(),
+  fade_seconds: z15.number().nonnegative().optional()
+}).strict();
+var CaptionGroupingSchema = z15.object({
+  max_words: z15.number().int().positive().optional(),
+  pause_gap: z15.number().nonnegative().optional()
+}).strict();
+var OverlayAnchorSchema = z15.enum([
+  "top-left",
+  "top-right",
+  "bottom-left",
+  "bottom-right"
+]);
+var OverlayTextStyleSchema = z15.object({
+  font_family: z15.string().optional(),
+  font_size: z15.number().positive().optional(),
+  font_weight: z15.union([z15.literal("normal"), z15.literal("bold"), z15.number()]).optional(),
+  color: z15.string().optional()
+}).strict();
+function validatePageNumberFormat(format, ctx) {
+  if (format.length === 0) {
+    ctx.addIssue({
+      code: z15.ZodIssueCode.custom,
+      message: "format must be a non-empty string"
+    });
+    return;
+  }
+  const open = (format.match(/\{/g) ?? []).length;
+  const close = (format.match(/\}/g) ?? []).length;
+  if (open !== close) {
+    ctx.addIssue({
+      code: z15.ZodIssueCode.custom,
+      message: `format has unbalanced braces (${open} '{' vs ${close} '}')`
+    });
+    return;
+  }
+  const groupRe = /\{([^{}]*)\}/g;
+  const groupRule = /^(current|total)(:0\d+d)?$/;
+  let m;
+  let sawCurrent = false;
+  let sawTotal = false;
+  while ((m = groupRe.exec(format)) !== null) {
+    const inner = m[1];
+    if (!groupRule.test(inner)) {
+      ctx.addIssue({
+        code: z15.ZodIssueCode.custom,
+        message: `format placeholder "{${inner}}" is not recognized \u2014 expected {current}, {total}, {current:0Nd}, or {total:0Nd}`
+      });
+      return;
+    }
+    if (inner.startsWith("current")) sawCurrent = true;
+    if (inner.startsWith("total")) sawTotal = true;
+  }
+  if (!sawCurrent && !sawTotal) {
+    ctx.addIssue({
+      code: z15.ZodIssueCode.custom,
+      message: "format must contain at least one {current} or {total} placeholder"
+    });
+  }
+}
+var OverlayHandleRuleSchema = z15.object({
+  text: z15.string().min(1),
+  anchor: OverlayAnchorSchema,
+  margin: z15.number().nonnegative().optional(),
+  style: OverlayTextStyleSchema.optional()
+}).strict();
+var OverlayPageNumberRuleSchema = z15.object({
+  format: z15.string().superRefine(validatePageNumberFormat),
+  anchor: OverlayAnchorSchema,
+  margin: z15.number().nonnegative().optional(),
+  style: OverlayTextStyleSchema.optional()
+}).strict();
+var OverlayRulesSchema = z15.object({
+  handle: OverlayHandleRuleSchema.optional(),
+  page_number: OverlayPageNumberRuleSchema.optional()
+}).strict();
+var StudioRecipeSchema = z15.object({
+  version: z15.string(),
+  name: z15.string(),
+  description: z15.string().optional(),
+  author: z15.string().optional(),
+  tags: z15.array(z15.string()).optional(),
+  silence_policy: SilencePolicySchema.optional(),
+  caption_style: CaptionStyleSchema.optional(),
+  caption_grouping: CaptionGroupingSchema.optional(),
+  // Phase 1.5 — first-class overlay rules
+  overlay_rules: OverlayRulesSchema.optional(),
+  // Reserved — Phase 3 (parse-opaque)
+  caption_highlight: z15.unknown().optional(),
+  transition_kit: z15.unknown().optional(),
+  palette: z15.unknown().optional(),
+  audio_policy: z15.unknown().optional(),
+  aspect_targets: z15.array(z15.unknown()).optional()
+}).strict();
+var RESERVED_RECIPE_FIELDS = [
+  "caption_highlight",
+  "transition_kit",
+  "palette",
+  "audio_policy",
+  "aspect_targets"
+];
+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 validateRecipe(recipe) {
+  const parsed = StudioRecipeSchema.safeParse(recipe);
+  if (!parsed.success) {
+    return { success: false, errors: formatErrors(parsed.error) };
+  }
+  const warnings = [];
+  const data = parsed.data;
+  for (const field of RESERVED_RECIPE_FIELDS) {
+    if (data[field] !== void 0) {
+      warnings.push(
+        `${field} is reserved for Phase 3 and currently has no effect.`
+      );
+    }
+  }
+  return { success: true, data, ...warnings.length > 0 && { warnings } };
+}
+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);
+}
+function serializeAtelier(doc) {
+  return yamlStringify(doc, { indent: 2 });
+}
+
+// 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/lib/video-project.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync, copyFileSync } from "fs";
+import { join, basename, extname, resolve as resolve2 } from "path";
+var VIDEO_PROJECT_VERSION = "1.0";
+var VIDEO_CUTLIST_VERSION = "1.1";
+var VIDEO_TRANSCRIPT_VERSION = "1.1";
+function effectiveSpan(cut, duration) {
+  return {
+    start: Math.max(0, cut.rawStart - cut.paddingPre),
+    end: Math.min(duration, cut.rawEnd + cut.paddingPost)
+  };
+}
+async function createVideoProject(srcPath, destDir) {
+  const absSrc = resolve2(srcPath);
+  const ext = extname(absSrc);
+  const stem = basename(absSrc, ext);
+  const projectDir = destDir ? resolve2(destDir) : join(resolve2(absSrc, ".."), stem);
+  if (!existsSync(projectDir)) {
+    mkdirSync(projectDir, { recursive: true });
+  }
+  const sourceFilename = `source${ext}`;
+  const sourcePath = join(projectDir, sourceFilename);
+  if (!existsSync(sourcePath)) {
+    copyFileSync(absSrc, sourcePath);
+  }
+  const compositionPath = join(projectDir, "project.atelier");
+  const transcriptPath = join(projectDir, "transcript.json");
+  const cutsPath = join(projectDir, "cuts.json");
+  const exportDir = join(projectDir, "export");
+  if (!existsSync(exportDir)) {
+    mkdirSync(exportDir, { recursive: true });
+  }
+  const manifest = {
+    source: sourceFilename,
+    composition: "project.atelier",
+    transcript: "transcript.json",
+    cuts: "cuts.json",
+    exportDir: "export/",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: VIDEO_PROJECT_VERSION
+  };
+  const draft = {
+    version: "1.0",
+    name: stem,
+    canvas: { width: 1920, height: 1080, fps: 30 },
+    assets: {
+      src: {
+        type: "video",
+        src: sourceFilename,
+        description: `Source: ${basename(absSrc)}`
+      }
+    },
+    layers: [
+      {
+        id: "clip-0",
+        visual: {
+          type: "video",
+          assetId: "src",
+          src: sourceFilename,
+          startFrame: 0,
+          sourceOffset: 0,
+          playbackRate: 1,
+          objectFit: "contain"
+        },
+        frame: { x: 0, y: 0 },
+        bounds: { width: 1920, height: 1080 }
+      }
+    ],
+    states: {
+      default: {
+        duration: 0,
+        deltas: []
+      }
+    }
+  };
+  if (!existsSync(compositionPath)) {
+    writeFileSync(compositionPath, JSON.stringify(draft, null, 2), "utf-8");
+  }
+  const initialCuts = {
+    version: VIDEO_CUTLIST_VERSION,
+    source: sourceFilename,
+    cuts: []
+  };
+  if (!existsSync(cutsPath)) {
+    writeFileSync(cutsPath, JSON.stringify(initialCuts, null, 2), "utf-8");
+  }
+  return {
+    dir: projectDir,
+    sourcePath,
+    compositionPath,
+    transcriptPath,
+    cutsPath,
+    exportDir,
+    manifest
+  };
+}
+function loadVideoProject(dir) {
+  const projectDir = resolve2(dir);
+  const possibleExts = [".mp4", ".mov", ".webm", ".mkv", ".avi"];
+  let sourceFilename = "source.mp4";
+  for (const ext of possibleExts) {
+    if (existsSync(join(projectDir, `source${ext}`))) {
+      sourceFilename = `source${ext}`;
+      break;
+    }
+  }
+  const manifest = {
+    source: sourceFilename,
+    composition: "project.atelier",
+    transcript: "transcript.json",
+    cuts: "cuts.json",
+    exportDir: "export/",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: VIDEO_PROJECT_VERSION
+  };
+  return {
+    dir: projectDir,
+    sourcePath: join(projectDir, sourceFilename),
+    compositionPath: join(projectDir, "project.atelier"),
+    transcriptPath: join(projectDir, "transcript.json"),
+    cutsPath: join(projectDir, "cuts.json"),
+    exportDir: join(projectDir, "export"),
+    manifest
+  };
+}
+function readCutList(project) {
+  if (!existsSync(project.cutsPath)) {
+    return { version: VIDEO_CUTLIST_VERSION, source: project.manifest.source, cuts: [] };
+  }
+  const raw = JSON.parse(readFileSync2(project.cutsPath, "utf-8"));
+  const cuts = raw.cuts.map((entry) => {
+    if ("rawStart" in entry) return entry;
+    return {
+      rawStart: entry.start,
+      rawEnd: entry.end,
+      paddingPre: 0,
+      paddingPost: 0,
+      ...entry.label !== void 0 && { label: entry.label }
+    };
+  });
+  return {
+    version: VIDEO_CUTLIST_VERSION,
+    source: raw.source,
+    cuts
+  };
+}
+function writeCutList(project, cuts) {
+  const payload = { ...cuts, version: VIDEO_CUTLIST_VERSION };
+  writeFileSync(project.cutsPath, JSON.stringify(payload, null, 2), "utf-8");
+}
+function readTranscript(project) {
+  if (!existsSync(project.transcriptPath)) return null;
+  const raw = JSON.parse(readFileSync2(project.transcriptPath, "utf-8"));
+  const segments = raw.segments.map((seg) => ({
+    text: seg.text,
+    start: seg.start,
+    end: seg.end,
+    words: seg.words.map((w) => {
+      if ("detected" in w) return w;
+      return {
+        detected: w.word,
+        text: w.word,
+        start: w.start,
+        end: w.end,
+        ...w.confidence !== void 0 && { confidence: w.confidence }
+      };
+    })
+  }));
+  return {
+    version: VIDEO_TRANSCRIPT_VERSION,
+    ...raw.language !== void 0 && { language: raw.language },
+    segments
+  };
+}
+function writeTranscript(project, transcript) {
+  const payload = { ...transcript, version: VIDEO_TRANSCRIPT_VERSION };
+  writeFileSync(project.transcriptPath, JSON.stringify(payload, null, 2), "utf-8");
+}
+function readComposition(project) {
+  return JSON.parse(readFileSync2(project.compositionPath, "utf-8"));
+}
+function writeComposition(project, doc) {
+  writeFileSync(project.compositionPath, JSON.stringify(doc, null, 2), "utf-8");
+}
+function rewriteCutLayers(doc, cuts, sourceFilename, sourceDuration, assetId = "src") {
+  const preserved = doc.layers.filter((l) => !(l.tags ?? []).includes("silence-trim"));
+  const fps = doc.canvas.fps;
+  let cumulativeFrame = 0;
+  const trimLayers = cuts.map((cut, idx) => {
+    const span = effectiveSpan(cut, sourceDuration);
+    const sourceOffsetFrames = Math.floor(span.start * fps) / fps;
+    const sourceEndFrames = Math.ceil(span.end * fps) / fps;
+    const durationFrames = Math.max(1, Math.round((sourceEndFrames - sourceOffsetFrames) * fps));
+    const layer = {
+      id: `clip-trim-${idx}`,
+      tags: ["silence-trim"],
+      visual: {
+        type: "video",
+        assetId,
+        src: sourceFilename,
+        startFrame: cumulativeFrame,
+        sourceOffset: sourceOffsetFrames,
+        sourceEnd: sourceEndFrames,
+        playbackRate: 1,
+        objectFit: "contain"
+      },
+      frame: { x: 0, y: 0 },
+      bounds: { width: doc.canvas.width, height: doc.canvas.height }
+    };
+    cumulativeFrame += durationFrames;
+    return layer;
+  });
+  return { ...doc, layers: [...preserved, ...trimLayers] };
+}
+
+// src/lib/recipe.ts
+import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve3, isAbsolute } from "path";
+import { homedir } from "os";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var RECIPE_VERSION = "1.0";
+function resolveRecipePath(pathOrName, projectDir) {
+  if (isAbsolute(pathOrName) || pathOrName.includes("/") || pathOrName.includes("\\")) {
+    return resolve3(pathOrName);
+  }
+  const candidates = [];
+  const exts = [".recipe.yaml", ".recipe.json", ".yaml", ".yml", ".json"];
+  if (projectDir) {
+    const projectRecipesDir = join2(resolve3(projectDir), ".atelier", "recipes");
+    for (const ext of exts) candidates.push(join2(projectRecipesDir, `${pathOrName}${ext}`));
+  }
+  const userRecipesDir = join2(homedir(), ".atelier", "recipes");
+  for (const ext of exts) candidates.push(join2(userRecipesDir, `${pathOrName}${ext}`));
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
+  }
+  throw new Error(
+    `Recipe "${pathOrName}" not found. Looked in:
+${candidates.map((c) => `  ${c}`).join("\n")}`
+  );
+}
+function loadRecipe(pathOrName, projectDir) {
+  const path = resolveRecipePath(pathOrName, projectDir);
+  const raw = readFileSync3(path, "utf-8");
+  let parsed;
+  if (path.endsWith(".json")) {
+    parsed = JSON.parse(raw);
+  } else {
+    parsed = parseYaml(raw);
+  }
+  const result = validateRecipe(parsed);
+  if (!result.success) {
+    const msg = result.errors.map((e) => `  ${e.path}: ${e.message}`).join("\n");
+    throw new Error(`Invalid recipe at ${path}:
+${msg}`);
+  }
+  return {
+    recipe: result.data,
+    path,
+    warnings: result.warnings ?? []
+  };
+}
+function scaffoldRecipeYaml(name) {
+  return `# Studio Recipe \u2014 ${name}
+# Phase 1 \u2014 manual authoring + apply
+# https://github.com/ascend42/a-atelier/blob/main/.paradigm/specs/studio-recipe.md
+
+version: "${RECIPE_VERSION}"
+name: "${name}"
+description: ""
+author: ""
+tags: []
+
+# \u2500\u2500 Silence-trim policy \u2014 consumed by \`atelier trim\` \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+silence_policy:
+  # silencedetect noise threshold (default: -30dB)
+  noise: "-30dB"
+  # Minimum silence duration to register, in seconds (default: 0.35)
+  min_silence: 0.35
+  # Default leading padding for new cuts, in seconds (default: 0.08)
+  default_padding_pre: 0.08
+  # Default trailing padding for new cuts, in seconds (default: 0.12)
+  default_padding_post: 0.12
+  # Re-detect match tolerance for preserving user padding, in seconds (default: 0.5)
+  match_tolerance: 0.5
+
+# \u2500\u2500 Caption visual style \u2014 consumed by \`atelier transcribe\` \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+caption_style:
+  font_family: "Inter"
+  font_size: 84
+  font_weight: "bold"     # normal | bold | numeric (100..900)
+  text_align: "center"    # left | center | right
+  color: "#FFFFFF"
+  y_ratio: 0.85           # 0=top, 1=bottom
+  width_ratio: 0.9
+  fade_seconds: 0.05
+
+# \u2500\u2500 Caption phrase grouping \u2014 consumed by \`atelier transcribe\` \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+caption_grouping:
+  max_words: 5
+  pause_gap: 0.4
+
+# \u2500\u2500 Overlay rules (Phase 1.5) \u2014 anchored handle + page-number overlays \u2500
+# overlay_rules:
+#   handle:
+#     text: "@username"
+#     anchor: "bottom-left"   # top-left | top-right | bottom-left | bottom-right
+#     margin: 24              # px from anchored edges
+#     style:
+#       font_family: "Inter"
+#       font_size: 36
+#       font_weight: "bold"
+#       color: "#FFFFFF"
+#   page_number:
+#     format: "{current}/{total}"   # supports {current:02d} / {total:02d} zero-pad
+#     anchor: "top-right"
+#     margin: 24
+#     style:
+#       font_family: "Inter"
+#       font_size: 36
+#       font_weight: "normal"
+#       color: "#FFFFFF"
+
+# \u2500\u2500 Phase 3 fields (reserved \u2014 Phase 1 ignores these) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+# caption_highlight: {}
+# transition_kit: {}
+# palette: {}
+# audio_policy: {}
+# aspect_targets: []
+`;
+}
+function applyRecipeToTrimOptions(recipe, cliOptions) {
+  const policy = recipe?.silence_policy;
+  if (!policy) return cliOptions;
+  return {
+    ...cliOptions,
+    noise: cliOptions.noise ?? policy.noise,
+    minSilence: cliOptions.minSilence ?? policy.min_silence,
+    padPre: cliOptions.padPre ?? policy.default_padding_pre,
+    padPost: cliOptions.padPost ?? policy.default_padding_post,
+    // matchTolerance is recipe-only at this layer (no CLI flag yet)
+    matchTolerance: cliOptions.matchTolerance ?? policy.match_tolerance
+  };
+}
+function applyRecipeToCaptionOptions(recipe) {
+  if (!recipe) return {};
+  const style = recipe.caption_style;
+  const grouping = recipe.caption_grouping;
+  const runtimeStyle = {};
+  if (style) {
+    if (style.font_family !== void 0) runtimeStyle.fontFamily = style.font_family;
+    if (style.font_size !== void 0) runtimeStyle.fontSize = style.font_size;
+    if (style.font_weight !== void 0) runtimeStyle.fontWeight = style.font_weight;
+    if (style.text_align !== void 0) runtimeStyle.textAlign = style.text_align;
+    if (style.color !== void 0) runtimeStyle.color = style.color;
+    if (style.y_ratio !== void 0) runtimeStyle.yRatio = style.y_ratio;
+    if (style.width_ratio !== void 0) runtimeStyle.widthRatio = style.width_ratio;
+    if (style.fade_seconds !== void 0) runtimeStyle.fadeSeconds = style.fade_seconds;
+  }
+  return {
+    ...Object.keys(runtimeStyle).length > 0 && { style: runtimeStyle },
+    ...grouping?.max_words !== void 0 && { maxWords: grouping.max_words },
+    ...grouping?.pause_gap !== void 0 && { pauseGap: grouping.pause_gap }
+  };
+}
+function applyRecipeToTranscribeOptions(recipe, cliOptions) {
+  if (!recipe) return cliOptions;
+  const captionOptions = applyRecipeToCaptionOptions(recipe);
+  return {
+    ...cliOptions,
+    captionOptions
+  };
+}
+function renderRecipeWithDefaults(recipe) {
+  const defaults = {
+    silence_policy: {
+      noise: "-30dB",
+      min_silence: 0.35,
+      default_padding_pre: 0.08,
+      default_padding_post: 0.12,
+      match_tolerance: 0.5
+    },
+    caption_style: {
+      font_family: "Inter",
+      font_size: 84,
+      font_weight: "bold",
+      text_align: "center",
+      color: "#FFFFFF",
+      y_ratio: 0.85,
+      width_ratio: 0.9,
+      fade_seconds: 0.05
+    },
+    caption_grouping: {
+      max_words: 5,
+      pause_gap: 0.4
+    }
+  };
+  return {
+    ...recipe,
+    silence_policy: { ...defaults.silence_policy, ...recipe.silence_policy },
+    caption_style: { ...defaults.caption_style, ...recipe.caption_style },
+    caption_grouping: { ...defaults.caption_grouping, ...recipe.caption_grouping }
+  };
+}
+function recipeToYaml(recipe) {
+  return stringifyYaml(recipe);
+}
+var DEFAULT_OVERLAY_MARGIN = 24;
+var DEFAULT_OVERLAY_TEXT_STYLE = {
+  fontFamily: "Inter",
+  fontSize: 24,
+  fontWeight: 600,
+  color: "#F5F5F7"
+};
+var HANDLE_LAYER_ID = "overlay-handle";
+var PAGE_NUMBER_LAYER_ID = "overlay-page-number";
+function applyRecipeToOverlay(doc, recipe, ctx) {
+  const preserved = doc.layers.filter((l) => !(l.tags ?? []).includes("overlay"));
+  const overlayLayers = [];
+  const rules = recipe.overlay_rules;
+  if (!rules) {
+    return { ...doc, layers: preserved };
+  }
+  if (rules.handle) {
+    overlayLayers.push(buildHandleLayer(rules.handle, doc.canvas));
+  }
+  if (rules.page_number) {
+    if (ctx?.currentIndex != null && ctx?.totalCount != null) {
+      overlayLayers.push(
+        buildPageNumberLayer(rules.page_number, doc.canvas, ctx.currentIndex, ctx.totalCount)
+      );
+    } else {
+      console.warn(
+        `applyRecipeToOverlay: recipe.overlay_rules.page_number present but currentIndex/totalCount not provided \u2014 skipping page_number layer.`
+      );
+    }
+  }
+  return {
+    ...doc,
+    layers: [...preserved, ...overlayLayers]
+  };
+}
+function buildHandleLayer(rule, canvas) {
+  const margin = rule.margin ?? DEFAULT_OVERLAY_MARGIN;
+  const { frame, anchorPoint } = anchorToFrame(rule.anchor, canvas, margin);
+  return {
+    id: HANDLE_LAYER_ID,
+    tags: ["overlay"],
+    visual: {
+      type: "text",
+      content: rule.text,
+      style: mergeOverlayStyle(rule.style)
+    },
+    frame,
+    bounds: { width: 600, height: 80 },
+    anchorPoint
+  };
+}
+function buildPageNumberLayer(rule, canvas, currentIndex, totalCount) {
+  const margin = rule.margin ?? DEFAULT_OVERLAY_MARGIN;
+  const { frame, anchorPoint } = anchorToFrame(rule.anchor, canvas, margin);
+  return {
+    id: PAGE_NUMBER_LAYER_ID,
+    tags: ["overlay"],
+    visual: {
+      type: "text",
+      content: renderPageNumberFormat(rule.format, currentIndex, totalCount),
+      style: mergeOverlayStyle(rule.style)
+    },
+    frame,
+    bounds: { width: 200, height: 80 },
+    anchorPoint
+  };
+}
+function anchorToFrame(anchor, canvas, margin) {
+  switch (anchor) {
+    case "top-left":
+      return { frame: { x: margin, y: margin }, anchorPoint: { x: 0, y: 0 } };
+    case "top-right":
+      return { frame: { x: canvas.width - margin, y: margin }, anchorPoint: { x: 1, y: 0 } };
+    case "bottom-left":
+      return { frame: { x: margin, y: canvas.height - margin }, anchorPoint: { x: 0, y: 1 } };
+    case "bottom-right":
+      return {
+        frame: { x: canvas.width - margin, y: canvas.height - margin },
+        anchorPoint: { x: 1, y: 1 }
+      };
+  }
+}
+function mergeOverlayStyle(style) {
+  return {
+    fontFamily: style?.font_family ?? DEFAULT_OVERLAY_TEXT_STYLE.fontFamily,
+    fontSize: style?.font_size ?? DEFAULT_OVERLAY_TEXT_STYLE.fontSize,
+    fontWeight: style?.font_weight ?? DEFAULT_OVERLAY_TEXT_STYLE.fontWeight,
+    color: style?.color ?? DEFAULT_OVERLAY_TEXT_STYLE.color
+  };
+}
+function renderPageNumberFormat(format, currentIndex, totalCount) {
+  return format.replace(
+    /\{(current|total)(?::0(\d+)d)?\}/g,
+    (_, name, padWidth) => {
+      const value = name === "current" ? currentIndex : totalCount;
+      const str = String(value);
+      if (padWidth) {
+        const width = parseInt(padWidth, 10);
+        return str.padStart(width, "0");
+      }
+      return str;
+    }
+  );
+}
+
+// src/lib/silence-detect.ts
+import { spawn } from "child_process";
+async function probeSilencedetect() {
+  const stdout = await runCapture("ffmpeg", ["-hide_banner", "-filters"]);
+  if (!/\bsilencedetect\b/.test(stdout)) {
+    throw new Error(
+      "Your ffmpeg build lacks the silencedetect filter. Install a standard ffmpeg \u2265 4.0 (brew install ffmpeg / apt install ffmpeg)."
+    );
+  }
+}
+async function probeDuration(sourcePath) {
+  const stdout = await runCapture("ffprobe", [
+    "-v",
+    "error",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "csv=p=0",
+    sourcePath
+  ]);
+  const n = parseFloat(stdout.trim());
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(`ffprobe returned invalid duration for ${sourcePath}: "${stdout}"`);
+  }
+  return n;
+}
+async function runSilenceDetect(sourcePath, options = {}) {
+  const noise = options.noise ?? "-30dB";
+  const minSilence = options.minSilence ?? 0.35;
+  const filter = `silencedetect=noise=${noise}:d=${minSilence}`;
+  const stderr = await runCaptureStderr("ffmpeg", [
+    "-hide_banner",
+    "-nostats",
+    "-i",
+    sourcePath,
+    "-af",
+    filter,
+    "-f",
+    "null",
+    "-"
+  ]);
+  return parseSilenceDetectStderr(stderr);
+}
+function parseSilenceDetectStderr(stderr) {
+  const intervals = [];
+  const startRe = /silence_start:\s*(-?[\d.]+)/;
+  const endRe = /silence_end:\s*(-?[\d.]+)/;
+  let pendingStart = null;
+  for (const line of stderr.split(/\r?\n/)) {
+    const sm = line.match(startRe);
+    if (sm) {
+      pendingStart = parseFloat(sm[1]);
+      continue;
+    }
+    const em = line.match(endRe);
+    if (em && pendingStart !== null) {
+      const end = parseFloat(em[1]);
+      intervals.push({ start: Math.max(0, pendingStart), end });
+      pendingStart = null;
+    }
+  }
+  return intervals;
+}
+function runCapture(cmd, args) {
+  return new Promise((resolve14, reject) => {
+    const proc = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    proc.stdout.on("data", (b) => stdout += b.toString());
+    proc.on("error", (err) => {
+      const e = err;
+      if (e.code === "ENOENT") {
+        reject(new Error(`${cmd} not found on PATH. Install ffmpeg/ffprobe (brew install ffmpeg).`));
+      } else {
+        reject(err);
+      }
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) reject(new Error(`${cmd} exited ${code}`));
+      else resolve14(stdout);
+    });
+  });
+}
+function runCaptureStderr(cmd, args) {
+  return new Promise((resolve14, reject) => {
+    const proc = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (b) => stderr += b.toString());
+    proc.on("error", (err) => {
+      const e = err;
+      if (e.code === "ENOENT") {
+        reject(new Error(`${cmd} not found on PATH. Install ffmpeg (brew install ffmpeg).`));
+      } else {
+        reject(err);
+      }
+    });
+    proc.on("close", () => resolve14(stderr));
+  });
+}
+
+// src/lib/cut-model.ts
+var DEFAULT_PADDING_PRE = 0.08;
+var DEFAULT_PADDING_POST = 0.12;
+var DEFAULT_MATCH_TOLERANCE = 0.5;
+function invertToSpeechIntervals(silences, duration) {
+  if (silences.length === 0) {
+    return duration > 0 ? [{ start: 0, end: duration }] : [];
+  }
+  const sorted = [...silences].sort((a, b) => a.start - b.start);
+  const speech = [];
+  if (sorted[0].start > 0) {
+    speech.push({ start: 0, end: sorted[0].start });
+  }
+  for (let i = 0; i < sorted.length - 1; i++) {
+    const gapStart = sorted[i].end;
+    const gapEnd = sorted[i + 1].start;
+    if (gapEnd > gapStart) {
+      speech.push({ start: gapStart, end: gapEnd });
+    }
+  }
+  const last = sorted[sorted.length - 1];
+  if (last.end < duration) {
+    speech.push({ start: last.end, end: duration });
+  }
+  return speech;
+}
+function buildInitialCuts(speech, paddingPre = DEFAULT_PADDING_PRE, paddingPost = DEFAULT_PADDING_POST) {
+  return speech.map((s) => ({
+    rawStart: s.start,
+    rawEnd: s.end,
+    paddingPre,
+    paddingPost
+  }));
+}
+function resolveOverlaps(cuts) {
+  for (let i = 0; i < cuts.length - 1; i++) {
+    const a = cuts[i];
+    const b = cuts[i + 1];
+    const aEnd = a.rawEnd + a.paddingPost;
+    const bStart = b.rawStart - b.paddingPre;
+    if (aEnd > bStart) {
+      const mid = (a.rawEnd + b.rawStart) / 2;
+      a.paddingPost = Math.max(0, mid - a.rawEnd);
+      b.paddingPre = Math.max(0, b.rawStart - mid);
+    }
+  }
+}
+function clampBoundaries(cuts, duration) {
+  if (cuts.length === 0) return;
+  const first = cuts[0];
+  if (first.rawStart - first.paddingPre < 0) {
+    first.paddingPre = first.rawStart;
+  }
+  const last = cuts[cuts.length - 1];
+  if (last.rawEnd + last.paddingPost > duration) {
+    last.paddingPost = Math.max(0, duration - last.rawEnd);
+  }
+}
+function mergeWithExisting(fresh, existing, tolerance = DEFAULT_MATCH_TOLERANCE) {
+  return fresh.map((f) => {
+    const match = existing.find(
+      (e) => Math.abs(e.rawStart - f.rawStart) < tolerance && Math.abs(e.rawEnd - f.rawEnd) < tolerance
+    );
+    if (!match) return f;
+    return {
+      rawStart: f.rawStart,
+      rawEnd: f.rawEnd,
+      paddingPre: match.paddingPre,
+      paddingPost: match.paddingPost,
+      ...match.label !== void 0 && { label: match.label }
+    };
+  });
+}
+function applyGlobalPadding(cuts, deltaSeconds) {
+  for (const cut of cuts) {
+    cut.paddingPre = Math.max(0, cut.paddingPre + deltaSeconds);
+    cut.paddingPost = Math.max(0, cut.paddingPost + deltaSeconds);
+  }
+}
+
+// src/commands/trim.ts
+async function trimProject(projectDir, options = {}) {
+  const project = loadVideoProject(projectDir);
+  await probeSilencedetect();
+  const duration = await probeDuration(project.sourcePath);
+  const silences = await runSilenceDetect(project.sourcePath, {
+    noise: options.noise,
+    minSilence: options.minSilence
+  });
+  const speech = invertToSpeechIntervals(silences, duration);
+  const padPre = options.padPre ?? DEFAULT_PADDING_PRE;
+  const padPost = options.padPost ?? DEFAULT_PADDING_POST;
+  let cuts = buildInitialCuts(speech, padPre, padPost);
+  if (!options.reset) {
+    const existing = readCutList(project);
+    cuts = mergeWithExisting(cuts, existing.cuts, options.matchTolerance);
+  }
+  if (typeof options.tightenMs === "number") {
+    applyGlobalPadding(cuts, -options.tightenMs / 1e3);
+  }
+  if (typeof options.loosenMs === "number") {
+    applyGlobalPadding(cuts, options.loosenMs / 1e3);
+  }
+  if (typeof options.cutIndex === "number") {
+    if (options.cutIndex < 0 || options.cutIndex >= cuts.length) {
+      throw new Error(
+        `--cut ${options.cutIndex} out of range (have ${cuts.length} cuts)`
+      );
+    }
+    if (options.padPre !== void 0) cuts[options.cutIndex].paddingPre = options.padPre;
+    if (options.padPost !== void 0) cuts[options.cutIndex].paddingPost = options.padPost;
+  }
+  resolveOverlaps(cuts);
+  clampBoundaries(cuts, duration);
+  const result = {
+    projectDir: project.dir,
+    duration,
+    cuts,
+    layerCount: cuts.length
+  };
+  if (options.dryRun) return result;
+  writeCutList(project, {
+    version: "1.1",
+    source: project.manifest.source,
+    cuts
+  });
+  const doc = readComposition(project);
+  const updated = rewriteCutLayers(doc, cuts, project.manifest.source, duration);
+  writeComposition(project, updated);
+  return result;
+}
+function formatResult(result) {
+  const lines = [];
+  lines.push(`Trimmed ${result.projectDir}`);
+  lines.push(`  source duration:  ${result.duration.toFixed(2)}s`);
+  lines.push(`  cuts:             ${result.cuts.length}`);
+  for (let i = 0; i < result.cuts.length; i++) {
+    const c = result.cuts[i];
+    const effStart = Math.max(0, c.rawStart - c.paddingPre);
+    const effEnd = Math.min(result.duration, c.rawEnd + c.paddingPost);
+    const dur = effEnd - effStart;
+    lines.push(
+      `    [${i}] ${effStart.toFixed(2)}s \u2192 ${effEnd.toFixed(2)}s (${dur.toFixed(2)}s, pad ${c.paddingPre.toFixed(2)}/${c.paddingPost.toFixed(2)})` + (c.label ? `  "${c.label}"` : "")
+    );
+  }
+  return lines.join("\n");
+}
+function trimCommand(program) {
+  program.command("trim <project>").description(
+    "Detect silence and rewrite project.atelier with parametric cuts (silence-trim tagged layers). Preserves user padding overrides on re-run."
+  ).option("--noise <dB>", "Silence threshold (default: -30dB)", "-30dB").option(
+    "--min-silence <seconds>",
+    "Minimum silence duration to register (default: 0.35)",
+    (v) => parseFloat(v),
+    0.35
+  ).option(
+    "--pad-pre <seconds>",
+    `Default leading padding (default: ${DEFAULT_PADDING_PRE})`,
+    (v) => parseFloat(v)
+  ).option(
+    "--pad-post <seconds>",
+    `Default trailing padding (default: ${DEFAULT_PADDING_POST})`,
+    (v) => parseFloat(v)
+  ).option("--tighten <ms>", "Reduce all current padding by N ms", (v) => parseInt(v, 10)).option("--loosen <ms>", "Increase all current padding by N ms", (v) => parseInt(v, 10)).option(
+    "--cut <index>",
+    "Apply --pad-pre / --pad-post to one specific cut only",
+    (v) => parseInt(v, 10)
+  ).option("--reset", "Discard existing padding; re-detect from scratch").option("--recipe <name>", "Apply a Studio Recipe's silence_policy as the baseline").option("--dry-run", "Print computed cuts; don't write files").option("--json", "Output result as JSON for piping").action(async (project, opts) => {
+    try {
+      let trimOpts = {
+        noise: opts.noise,
+        minSilence: opts.minSilence,
+        padPre: opts.padPre,
+        padPost: opts.padPost,
+        tightenMs: opts.tighten,
+        loosenMs: opts.loosen,
+        cutIndex: opts.cut,
+        reset: opts.reset,
+        dryRun: opts.dryRun
+      };
+      if (opts.recipe) {
+        const { recipe } = loadRecipe(opts.recipe, project);
+        trimOpts = applyRecipeToTrimOptions(recipe, trimOpts);
+      }
+      const result = await trimProject(project, trimOpts);
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(formatResult(result));
+        if (opts.dryRun) console.log("(dry-run \u2014 no files written)");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`atelier trim: ${msg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/lib/whisper.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+async function probeWhisper() {
+  if (await commandExists("whisper-cli")) return "whisper-cpp";
+  if (process.env.OPENAI_API_KEY) return "openai-api";
+  return "none";
+}
+async function runWhisperCpp(sourcePath, options = {}) {
+  const model = options.modelPath ?? options.model ?? "base.en";
+  const args = [
+    sourcePath,
+    "--model",
+    model,
+    "--output-json",
+    "--word-thold",
+    "0.01",
+    // emit word-level timestamps
+    "--print-progress",
+    "false"
+  ];
+  if (options.language) {
+    args.push("--language", options.language);
+  }
+  return runCaptureStdout("whisper-cli", args);
+}
+function parseWhisperCppJson(jsonStr) {
+  const raw = JSON.parse(jsonStr);
+  const segments = (raw.transcription ?? []).map((seg) => {
+    const segStart = (seg.offsets?.from ?? 0) / 1e3;
+    const segEnd = (seg.offsets?.to ?? 0) / 1e3;
+    const segText = seg.text.trim();
+    let words;
+    if (seg.tokens && seg.tokens.length > 0) {
+      words = seg.tokens.filter((t) => t.text.trim().length > 0 && !t.text.startsWith("[_")).map((t) => ({
+        detected: t.text.trim(),
+        text: t.text.trim(),
+        start: (t.offsets?.from ?? segStart * 1e3) / 1e3,
+        end: (t.offsets?.to ?? segEnd * 1e3) / 1e3,
+        ...t.p !== void 0 && { confidence: t.p }
+      }));
+    } else {
+      const tokens = segText.split(/\s+/).filter((t) => t.length > 0);
+      const span = segEnd - segStart;
+      const per = tokens.length > 0 ? span / tokens.length : 0;
+      words = tokens.map((tok, i) => ({
+        detected: tok,
+        text: tok,
+        start: segStart + i * per,
+        end: segStart + (i + 1) * per
+      }));
+    }
+    return {
+      text: segText,
+      start: segStart,
+      end: segEnd,
+      words
+    };
+  });
+  return {
+    version: "1.1",
+    ...raw.result?.language !== void 0 && { language: raw.result.language },
+    segments
+  };
+}
+async function commandExists(name) {
+  if (name.startsWith("/") || name.match(/^[A-Z]:\\/)) {
+    return existsSync3(name);
+  }
+  return new Promise((resolve14) => {
+    const probe = spawn2(process.platform === "win32" ? "where" : "which", [name], {
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    probe.on("error", () => resolve14(false));
+    probe.on("close", (code) => resolve14(code === 0));
+  });
+}
+function runCaptureStdout(cmd, args) {
+  return new Promise((resolve14, reject) => {
+    const proc = spawn2(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (b) => stdout += b.toString());
+    proc.stderr.on("data", (b) => stderr += b.toString());
+    proc.on("error", (err) => {
+      const e = err;
+      if (e.code === "ENOENT") {
+        reject(new Error(
+          `${cmd} not found on PATH. Install whisper.cpp (brew install whisper-cpp) or run \`pnpm add @xenova/transformers\` for the ONNX fallback.`
+        ));
+      } else {
+        reject(err);
+      }
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`${cmd} exited ${code}
+${stderr}`));
+      } else {
+        resolve14(stdout);
+      }
+    });
+  });
+}
+
+// src/lib/transcript-model.ts
+var DEFAULT_TRANSCRIPT_MATCH_TOLERANCE = 0.3;
+var DEFAULT_PHRASE_MAX_WORDS = 5;
+var DEFAULT_PHRASE_PAUSE_GAP_SECONDS = 0.4;
+var END_PUNCT = /[.!?,;:]\s*$/;
+function flattenWords(transcript) {
+  return transcript.segments.flatMap((s) => s.words);
+}
+function groupIntoPhrases(transcript, options = {}) {
+  const maxWords = options.maxWords ?? DEFAULT_PHRASE_MAX_WORDS;
+  const pauseGap = options.pauseGap ?? DEFAULT_PHRASE_PAUSE_GAP_SECONDS;
+  const phrases = [];
+  const visibleWords = flattenWords(transcript).filter((w) => !w.hidden);
+  let current = [];
+  for (let i = 0; i < visibleWords.length; i++) {
+    const w = visibleWords[i];
+    current.push(w);
+    const next = visibleWords[i + 1];
+    const gap = next ? next.start - w.end : 0;
+    const endsOnPunct = END_PUNCT.test(w.text);
+    const atMax = current.length >= maxWords;
+    if (!next || atMax || endsOnPunct || gap > pauseGap) {
+      phrases.push({
+        start: current[0].start,
+        end: current[current.length - 1].end,
+        text: current.map((c) => c.text).join(" "),
+        words: current
+      });
+      current = [];
+    }
+  }
+  return phrases;
+}
+function mergeTranscriptWithExisting(fresh, existing, tolerance = DEFAULT_TRANSCRIPT_MATCH_TOLERANCE) {
+  const existingWords = flattenWords(existing);
+  const merged = {
+    version: "1.1",
+    ...fresh.language !== void 0 && { language: fresh.language },
+    segments: fresh.segments.map((seg) => ({
+      text: seg.text,
+      start: seg.start,
+      end: seg.end,
+      words: seg.words.map((freshWord) => {
+        const match = existingWords.find(
+          (e) => !e.userAdded && Math.abs(e.start - freshWord.start) < tolerance && e.detected === freshWord.detected
+        );
+        if (!match) return freshWord;
+        return {
+          detected: freshWord.detected,
+          text: match.text,
+          start: freshWord.start,
+          end: freshWord.end,
+          ...freshWord.confidence !== void 0 && { confidence: freshWord.confidence },
+          ...match.userEdited && { userEdited: true },
+          ...match.hidden && { hidden: true }
+        };
+      })
+    }))
+  };
+  const orphans = existingWords.filter((w) => w.userAdded);
+  for (const orphan of orphans) {
+    const segIdx = merged.segments.findIndex(
+      (s) => orphan.start >= s.start && orphan.start <= s.end
+    );
+    const targetSeg = segIdx >= 0 ? merged.segments[segIdx] : merged.segments[merged.segments.length - 1];
+    if (!targetSeg) continue;
+    const insertIdx = targetSeg.words.findIndex((w) => w.start > orphan.start);
+    if (insertIdx === -1) targetSeg.words.push(orphan);
+    else targetSeg.words.splice(insertIdx, 0, orphan);
+  }
+  return merged;
+}
+function applyTextEdit(transcript, wordIndex, newText) {
+  return mapWord(transcript, wordIndex, (w) => ({
+    ...w,
+    text: newText,
+    userEdited: true
+  }));
+}
+function applyBatchReplace(transcript, find, replace) {
+  return {
+    ...transcript,
+    segments: transcript.segments.map((seg) => ({
+      ...seg,
+      words: seg.words.map(
+        (w) => w.detected === find ? { ...w, text: replace, userEdited: true } : w
+      )
+    }))
+  };
+}
+function applyHide(transcript, wordIndex) {
+  return mapWord(transcript, wordIndex, (w) => ({ ...w, hidden: true }));
+}
+function applyAdd(transcript, afterIndex, text, duration = 0.15) {
+  const flat = flattenWords(transcript);
+  if (afterIndex < 0 || afterIndex >= flat.length) {
+    throw new Error(`afterIndex ${afterIndex} out of range (have ${flat.length} words)`);
+  }
+  const anchor = flat[afterIndex];
+  const newWord = {
+    detected: text,
+    text,
+    start: anchor.end,
+    end: anchor.end + duration,
+    userAdded: true
+  };
+  let cursor = 0;
+  return {
+    ...transcript,
+    segments: transcript.segments.map((seg) => {
+      const segStart = cursor;
+      cursor += seg.words.length;
+      if (afterIndex < segStart || afterIndex >= cursor) return seg;
+      const localIdx = afterIndex - segStart;
+      return {
+        ...seg,
+        words: [...seg.words.slice(0, localIdx + 1), newWord, ...seg.words.slice(localIdx + 1)]
+      };
+    })
+  };
+}
+function applyMerge(transcript, firstIndex) {
+  const flat = flattenWords(transcript);
+  if (firstIndex < 0 || firstIndex >= flat.length - 1) {
+    throw new Error(`firstIndex ${firstIndex} out of range for merge`);
+  }
+  const a = flat[firstIndex];
+  const b = flat[firstIndex + 1];
+  const mergedWord = {
+    detected: a.detected + b.detected,
+    text: a.text + b.text,
+    start: a.start,
+    end: b.end,
+    userEdited: true
+  };
+  let cursor = 0;
+  return {
+    ...transcript,
+    segments: transcript.segments.map((seg) => {
+      const segStart = cursor;
+      cursor += seg.words.length;
+      if (firstIndex < segStart || firstIndex >= cursor - 1) return seg;
+      const localIdx = firstIndex - segStart;
+      return {
+        ...seg,
+        words: [...seg.words.slice(0, localIdx), mergedWord, ...seg.words.slice(localIdx + 2)]
+      };
+    })
+  };
+}
+function applySplit(transcript, wordIndex, fraction, firstText, secondText) {
+  if (fraction <= 0 || fraction >= 1) {
+    throw new Error(`split fraction must be in (0, 1), got ${fraction}`);
+  }
+  const flat = flattenWords(transcript);
+  if (wordIndex < 0 || wordIndex >= flat.length) {
+    throw new Error(`wordIndex ${wordIndex} out of range`);
+  }
+  const w = flat[wordIndex];
+  const splitTime = w.start + (w.end - w.start) * fraction;
+  const cutChar = Math.max(1, Math.floor(w.text.length * fraction));
+  const first = {
+    detected: w.detected,
+    text: firstText ?? w.text.slice(0, cutChar),
+    start: w.start,
+    end: splitTime,
+    userEdited: true
+  };
+  const second = {
+    detected: w.detected,
+    text: secondText ?? w.text.slice(cutChar),
+    start: splitTime,
+    end: w.end,
+    userEdited: true
+  };
+  let cursor = 0;
+  return {
+    ...transcript,
+    segments: transcript.segments.map((seg) => {
+      const segStart = cursor;
+      cursor += seg.words.length;
+      if (wordIndex < segStart || wordIndex >= cursor) return seg;
+      const localIdx = wordIndex - segStart;
+      return {
+        ...seg,
+        words: [...seg.words.slice(0, localIdx), first, second, ...seg.words.slice(localIdx + 1)]
+      };
+    })
+  };
+}
+function mapWord(transcript, wordIndex, fn) {
+  const flat = flattenWords(transcript);
+  if (wordIndex < 0 || wordIndex >= flat.length) {
+    throw new Error(`wordIndex ${wordIndex} out of range (have ${flat.length} words)`);
+  }
+  let cursor = 0;
+  return {
+    ...transcript,
+    segments: transcript.segments.map((seg) => {
+      const segStart = cursor;
+      cursor += seg.words.length;
+      if (wordIndex < segStart || wordIndex >= cursor) return seg;
+      const localIdx = wordIndex - segStart;
+      return {
+        ...seg,
+        words: seg.words.map((w, i) => i === localIdx ? fn(w) : w)
+      };
+    })
+  };
+}
+
+// src/lib/caption-builder.ts
+var DEFAULT_STYLE = {
+  fontFamily: "Inter",
+  fontSize: 84,
+  fontWeight: "bold",
+  textAlign: "center",
+  color: "#FFFFFF",
+  yRatio: 0.85,
+  widthRatio: 0.9,
+  fadeSeconds: 0.05
+};
+function buildCaptionLayers(transcript, canvas, options = {}) {
+  const style = { ...DEFAULT_STYLE, ...options.style };
+  const phrases = groupIntoPhrases(transcript, {
+    maxWords: options.maxWords,
+    pauseGap: options.pauseGap
+  });
+  const layers = [];
+  const deltas = [];
+  const fps = canvas.fps;
+  phrases.forEach((phrase, idx) => {
+    const layerId = `caption-${idx}`;
+    layers.push(buildPhraseLayer(layerId, phrase, canvas, style));
+    deltas.push(...buildPhraseDeltas(layerId, phrase, style.fadeSeconds, fps));
+  });
+  return { layers, deltas };
+}
+function rewriteCaptionLayers(doc, transcript, options = {}) {
+  const preserved = doc.layers.filter((l) => !(l.tags ?? []).includes("caption"));
+  const { layers: captionLayers, deltas: captionDeltas } = buildCaptionLayers(
+    transcript,
+    doc.canvas,
+    options
+  );
+  const captionLayerIds = new Set(captionLayers.map((l) => l.id));
+  const stateNames = Object.keys(doc.states);
+  const targetStateName = stateNames.includes("default") ? "default" : stateNames[0];
+  const states = { ...doc.states };
+  if (targetStateName && states[targetStateName]) {
+    const existing = states[targetStateName];
+    const preservedDeltas = existing.deltas.filter(
+      (d) => !captionLayerIds.has(d.layer)
+    );
+    states[targetStateName] = {
+      ...existing,
+      deltas: [...preservedDeltas, ...captionDeltas]
+    };
+  }
+  return {
+    ...doc,
+    layers: [...preserved, ...captionLayers],
+    states
+  };
+}
+function buildPhraseLayer(id, phrase, canvas, style) {
+  return {
+    id,
+    tags: ["caption"],
+    visual: {
+      type: "text",
+      content: phrase.text,
+      style: {
+        fontFamily: style.fontFamily,
+        fontSize: style.fontSize,
+        fontWeight: style.fontWeight,
+        textAlign: style.textAlign,
+        color: style.color
+      }
+    },
+    frame: {
+      x: canvas.width / 2,
+      y: canvas.height * style.yRatio
+    },
+    bounds: {
+      width: canvas.width * style.widthRatio,
+      height: Math.max(120, style.fontSize * 1.6)
+    },
+    anchorPoint: { x: 0.5, y: 0.5 },
+    opacity: 0
+  };
+}
+function buildPhraseDeltas(layerId, phrase, fadeSeconds, fps) {
+  const fadeFrames = Math.max(1, Math.round(fadeSeconds * fps));
+  const startFrame = Math.floor(phrase.start * fps);
+  const endFrame = Math.ceil(phrase.end * fps);
+  const fadeOutStart = Math.max(startFrame + 1, endFrame - fadeFrames);
+  return [
+    // Fade in to visible at phrase start
+    {
+      layer: layerId,
+      property: "opacity",
+      range: [Math.max(0, startFrame - fadeFrames), startFrame],
+      from: 0,
+      to: 1,
+      easing: "ease-out"
+    },
+    // Hold visible through the phrase
+    // (no explicit delta needed — value persists between deltas)
+    // Fade out at phrase end
+    {
+      layer: layerId,
+      property: "opacity",
+      range: [fadeOutStart, endFrame],
+      from: 1,
+      to: 0,
+      easing: "ease-in"
+    }
+  ];
+}
+
+// src/commands/transcribe.ts
+async function transcribeProject(projectDir, options = {}) {
+  const project = loadVideoProject(projectDir);
+  const backend = await probeWhisper();
+  if (backend === "none") {
+    throw new Error(
+      "No Whisper backend available. Install whisper.cpp (brew install whisper-cpp) or set OPENAI_API_KEY and pass --use-api."
+    );
+  }
+  if (backend === "openai-api") {
+    throw new Error(
+      "OpenAI API backend is not yet implemented. Install whisper.cpp for local transcription."
+    );
+  }
+  const rawJson = await runWhisperCpp(project.sourcePath, {
+    model: options.model,
+    language: options.language
+  });
+  let transcript = parseWhisperCppJson(rawJson);
+  if (!options.reset) {
+    const existing = readTranscript(project);
+    if (existing) {
+      transcript = mergeTranscriptWithExisting(transcript, existing);
+    }
+  }
+  const wordCount = transcript.segments.reduce((n, s) => n + s.words.length, 0);
+  const result = {
+    projectDir: project.dir,
+    backend,
+    transcript,
+    wordCount,
+    captionsGenerated: false
+  };
+  if (options.dryRun) return result;
+  writeTranscript(project, transcript);
+  if (!options.noCaptions) {
+    const doc = readComposition(project);
+    const updated = rewriteCaptionLayers(doc, transcript, options.captionOptions);
+    writeComposition(project, updated);
+    result.captionsGenerated = true;
+  }
+  return result;
+}
+function formatResult2(result) {
+  const lines = [];
+  lines.push(`Transcribed ${result.projectDir} via ${result.backend}`);
+  if (result.transcript.language) {
+    lines.push(`  language:  ${result.transcript.language}`);
+  }
+  lines.push(`  segments:  ${result.transcript.segments.length}`);
+  lines.push(`  words:     ${result.wordCount}`);
+  if (result.captionsGenerated) {
+    lines.push(`  captions:  written to project.atelier`);
+  } else {
+    lines.push(`  captions:  skipped`);
+  }
+  return lines.join("\n");
+}
+function transcribeCommand(program) {
+  program.command("transcribe <project>").description(
+    "Transcribe source video via Whisper, write transcript.json, and rewrite caption-tagged TextVisual layers in project.atelier. Preserves user transcript edits on re-run."
+  ).option("--model <name>", "Whisper model: tiny|base|small|medium|large-v3", "base.en").option("--language <code>", "BCP-47 language hint (omit for autodetect)").option("--reset", "Discard existing user edits; full fresh transcript").option("--no-captions", "Write transcript.json only; skip caption layer generation").option("--recipe <name>", "Apply a Studio Recipe's caption_style + caption_grouping").option("--dry-run", "Print transcript; don't write files").option("--json", "Output result as JSON for piping").action(async (project, opts) => {
+    try {
+      let transcribeOpts = {
+        model: opts.model,
+        language: opts.language,
+        reset: opts.reset,
+        noCaptions: !opts.captions,
+        dryRun: opts.dryRun
+      };
+      if (opts.recipe) {
+        const { recipe } = loadRecipe(opts.recipe, project);
+        transcribeOpts = applyRecipeToTranscribeOptions(recipe, transcribeOpts);
+      }
+      const result = await transcribeProject(project, transcribeOpts);
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(formatResult2(result));
+        if (opts.dryRun) console.log("(dry-run \u2014 no files written)");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`atelier transcribe: ${msg}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/transcript.ts
+function loadOrThrow(projectDir) {
+  const project = loadVideoProject(projectDir);
+  const transcript = readTranscript(project);
+  if (!transcript) {
+    throw new Error(
+      `No transcript.json in ${projectDir}. Run \`atelier transcribe ${projectDir}\` first.`
+    );
+  }
+  return { project, transcript };
+}
+function save(project, transcript, noRegenerate) {
+  writeTranscript(project, transcript);
+  if (!noRegenerate) {
+    const doc = readComposition(project);
+    const updated = rewriteCaptionLayers(doc, transcript);
+    writeComposition(project, updated);
+  }
+}
+function transcriptCommand(program) {
+  const transcript = program.command("transcript").description("Edit transcript.json \u2014 fix, add, delete, merge, split, list");
+  transcript.command("fix <project>").description("Apply text correction(s). Use --replace 'wrong=right' for batch, or --word <idx> --text '<correction>' for single edit.").option("--replace <pair...>", "Batch find/replace, format: 'detected=replacement' (repeatable)").option("--word <index>", "Single-word edit by index", (v) => parseInt(v, 10)).option("--text <text>", "Correction text (paired with --word)").option("--no-regenerate", "Skip caption layer regeneration after edit").action(async (projectDir, opts) => {
+    try {
+      const { project, transcript: transcript2 } = loadOrThrow(projectDir);
+      let updated = transcript2;
+      if (opts.replace?.length) {
+        for (const pair of opts.replace) {
+          const [find, repl] = pair.split("=");
+          if (!find || repl === void 0) {
+            throw new Error(`Invalid --replace pair: "${pair}". Use 'detected=replacement'.`);
+          }
+          updated = applyBatchReplace(updated, find, repl);
+        }
+      }
+      if (typeof opts.word === "number") {
+        if (opts.text === void 0) {
+          throw new Error("--word requires --text <correction>");
+        }
+        updated = applyTextEdit(updated, opts.word, opts.text);
+      }
+      if (!opts.replace?.length && opts.word === void 0) {
+        throw new Error("Provide --replace 'wrong=right' or --word <idx> --text '...'");
+      }
+      save(project, updated, !opts.regenerate);
+      console.log(`Updated transcript in ${project.dir}`);
+    } catch (err) {
+      console.error(`atelier transcript fix: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  transcript.command("add <project>").description("Insert a user-added word after the anchor word.").requiredOption("--after-word <index>", "Anchor word index", (v) => parseInt(v, 10)).requiredOption("--text <text>", "Text of the new word").option("--duration <seconds>", "Word duration in seconds (default: 0.15)", (v) => parseFloat(v), 0.15).option("--no-regenerate", "Skip caption layer regeneration").action(async (projectDir, opts) => {
+    try {
+      const { project, transcript: transcript2 } = loadOrThrow(projectDir);
+      const updated = applyAdd(transcript2, opts.afterWord, opts.text, opts.duration);
+      save(project, updated, !opts.regenerate);
+      console.log(`Inserted "${opts.text}" after word ${opts.afterWord} in ${project.dir}`);
+    } catch (err) {
+      console.error(`atelier transcript add: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  transcript.command("delete <project>").description("Hide a word (excluded from captions, kept in transcript).").requiredOption("--word <index>", "Word index", (v) => parseInt(v, 10)).option("--no-regenerate", "Skip caption layer regeneration").action(async (projectDir, opts) => {
+    try {
+      const { project, transcript: transcript2 } = loadOrThrow(projectDir);
+      const updated = applyHide(transcript2, opts.word);
+      save(project, updated, !opts.regenerate);
+      console.log(`Hidden word ${opts.word} in ${project.dir}`);
+    } catch (err) {
+      console.error(`atelier transcript delete: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  transcript.command("merge <project>").description("Merge two adjacent words at indices i and i+1.").requiredOption("--word <index>", "First of the two words to merge", (v) => parseInt(v, 10)).option("--no-regenerate", "Skip caption layer regeneration").action(async (projectDir, opts) => {
+    try {
+      const { project, transcript: transcript2 } = loadOrThrow(projectDir);
+      const updated = applyMerge(transcript2, opts.word);
+      save(project, updated, !opts.regenerate);
+      console.log(`Merged words ${opts.word} and ${opts.word + 1} in ${project.dir}`);
+    } catch (err) {
+      console.error(`atelier transcript merge: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  transcript.command("split <project>").description("Split one word at a fractional point.").requiredOption("--word <index>", "Word to split", (v) => parseInt(v, 10)).requiredOption("--at <fraction>", "Split point (0\u20131)", (v) => parseFloat(v)).option("--first <text>", "Override text for first half").option("--second <text>", "Override text for second half").option("--no-regenerate", "Skip caption layer regeneration").action(async (projectDir, opts) => {
+    try {
+      const { project, transcript: transcript2 } = loadOrThrow(projectDir);
+      const updated = applySplit(transcript2, opts.word, opts.at, opts.first, opts.second);
+      save(project, updated, !opts.regenerate);
+      console.log(`Split word ${opts.word} at ${opts.at} in ${project.dir}`);
+    } catch (err) {
+      console.error(`atelier transcript split: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  transcript.command("list <project>").description("Print all words with their indices for reference.").option("--json", "Output as JSON").action(async (projectDir, opts) => {
+    try {
+      const { transcript: transcript2 } = loadOrThrow(projectDir);
+      const words = flattenWords(transcript2);
+      if (opts.json) {
+        console.log(JSON.stringify(words.map((w, i) => ({ index: i, ...w })), null, 2));
+      } else {
+        for (let i = 0; i < words.length; i++) {
+          const w = words[i];
+          const flags = [];
+          if (w.userEdited) flags.push("edited");
+          if (w.userAdded) flags.push("added");
+          if (w.hidden) flags.push("hidden");
+          const flagStr = flags.length ? ` [${flags.join(", ")}]` : "";
+          const editedDisplay = w.text !== w.detected ? ` \u2190 "${w.detected}"` : "";
+          console.log(
+            `  [${i.toString().padStart(4)}]  ${w.start.toFixed(2).padStart(7)}s  "${w.text}"${editedDisplay}${flagStr}`
+          );
+        }
+      }
+    } catch (err) {
+      console.error(`atelier transcript list: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/captions.ts
+function captionsCommand(program) {
+  const captions = program.command("captions").description("Manage caption layers in a VideoProject");
+  captions.command("regenerate <project>").description(
+    "Re-derive caption-tagged TextVisual layers from the current transcript.json. Used when caption styling changes without re-running Whisper."
+  ).option("--recipe <name>", "Apply a Studio Recipe's caption_style + caption_grouping").action(async (projectDir, opts) => {
+    try {
+      const project = loadVideoProject(projectDir);
+      const transcript = readTranscript(project);
+      if (!transcript) {
+        throw new Error(
+          `No transcript.json in ${projectDir}. Run \`atelier transcribe ${projectDir}\` first.`
+        );
+      }
+      const captionOptions = opts.recipe ? applyRecipeToCaptionOptions(loadRecipe(opts.recipe, projectDir).recipe) : {};
+      const doc = readComposition(project);
+      const updated = rewriteCaptionLayers(doc, transcript, captionOptions);
+      writeComposition(project, updated);
+      const captionLayers = updated.layers.filter(
+        (l) => (l.tags ?? []).includes("caption")
+      );
+      console.log(
+        `Regenerated ${captionLayers.length} caption layer${captionLayers.length === 1 ? "" : "s"} in ${project.dir}`
+      );
+    } catch (err) {
+      console.error(`atelier captions regenerate: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/recipe.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, resolve as resolve4 } from "path";
+function recipeCommand(program) {
+  const recipe = program.command("recipe").description("Manage Studio Recipes \u2014 reusable style presets");
+  recipe.command("new <name>").description("Scaffold a starter recipe YAML with all current defaults filled in").option("--dir <path>", "Where to write the recipe (default: ./.atelier/recipes/)").action((name, opts) => {
+    try {
+      const baseDir = opts.dir ?? join3(resolve4(process.cwd()), ".atelier", "recipes");
+      if (!existsSync4(baseDir)) {
+        mkdirSync2(baseDir, { recursive: true });
+      }
+      const hasKnownExt = /\.(recipe\.yaml|recipe\.json|yaml|yml|json)$/i.test(name);
+      const fileName = hasKnownExt ? name : `${name}.recipe.yaml`;
+      const outPath = join3(baseDir, fileName);
+      if (existsSync4(outPath)) {
+        throw new Error(`Recipe already exists at ${outPath} \u2014 refusing to overwrite.`);
+      }
+      const recipeName = name.replace(/\.(recipe\.yaml|recipe\.json|yaml|yml|json)$/i, "");
+      const yaml = scaffoldRecipeYaml(recipeName);
+      writeFileSync2(outPath, yaml, "utf-8");
+      console.log(`Created ${outPath}`);
+    } catch (err) {
+      console.error(`atelier recipe new: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+  recipe.command("validate <path>").description("Validate a recipe against the schema (^valid-recipe gate). Warns on reserved Phase 3 fields.").option("--json", "Output result as JSON").action((path, opts) => {
+    try {
+      const loaded = loadRecipe(path, process.cwd());
+      if (opts.json) {
+        console.log(JSON.stringify({
+          valid: true,
+          path: loaded.path,
+          warnings: loaded.warnings
+        }, null, 2));
+      } else {
+        console.log(`PASS  ${loaded.path}`);
+        for (const w of loaded.warnings) {
+          console.log(`  \u26A0  ${w}`);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ valid: false, error: msg }, null, 2));
+      } else {
+        console.error(`FAIL  ${path}`);
+        console.error(`  ${msg}`);
+      }
+      process.exit(1);
+    }
+  });
+  recipe.command("show <path>").description("Print a recipe; --with-defaults fills in every omitted field with its code default.").option("--with-defaults", "Overlay code defaults onto omitted fields").action((path, opts) => {
+    try {
+      const loaded = loadRecipe(path, process.cwd());
+      const out = opts.withDefaults ? renderRecipeWithDefaults(loaded.recipe) : loaded.recipe;
+      console.log(recipeToYaml(out));
+      for (const w of loaded.warnings) {
+        console.error(`# \u26A0  ${w}`);
+      }
+    } catch (err) {
+      console.error(`atelier recipe show: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/apply-recipe.ts
+function applyRecipeCommand(program) {
+  program.command("apply-recipe <project> <recipe>").description(
+    "Apply a Studio Recipe by running atelier trim + atelier transcribe with the same recipe, in that order."
+  ).option("--reset", "Apply --reset to both pipelines (destructive \u2014 discards existing user padding and transcript edits)").option("--no-trim", "Skip the atelier trim step").option("--no-transcribe", "Skip the atelier transcribe step").action(async (project, recipeRef, opts) => {
+    try {
+      const { recipe, path, warnings } = loadRecipe(recipeRef, project);
+      console.log(`Loaded recipe ${path}`);
+      for (const w of warnings) console.log(`  \u26A0  ${w}`);
+      if (opts.trim) {
+        const trimOpts = applyRecipeToTrimOptions(recipe, { reset: opts.reset });
+        console.log(`
+Running atelier trim...`);
+        const r = await trimProject(project, trimOpts);
+        console.log(`  ${r.cuts.length} cut${r.cuts.length === 1 ? "" : "s"} written`);
+      }
+      if (opts.transcribe) {
+        const transcribeOpts = applyRecipeToTranscribeOptions(recipe, { reset: opts.reset });
+        console.log(`
+Running atelier transcribe...`);
+        const r = await transcribeProject(project, transcribeOpts);
+        console.log(`  ${r.wordCount} words, ${r.captionsGenerated ? "captions written" : "captions skipped"}`);
+      }
+      if (recipe.overlay_rules) {
+        const vp = loadVideoProject(project);
+        const doc = readComposition(vp);
+        const updated = applyRecipeToOverlay(doc, recipe);
+        writeComposition(vp, updated);
+        console.log(`
+Applied overlay rules to ${vp.compositionPath}`);
+      }
+      console.log(`
+Done.`);
+    } catch (err) {
+      console.error(`atelier apply-recipe: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/lib/render-image.ts
+import { createCanvas, loadImage } from "@napi-rs/canvas";
+function fitImageToCanvas(canvas, natural) {
+  const cw = canvas.width;
+  const ch = canvas.height;
+  const iw = natural.width;
+  const ih = natural.height;
+  if (!iw || !ih) {
+    return { bounds: { width: cw, height: ch }, frame: { x: cw / 2, y: ch / 2 } };
+  }
+  const imageAspect = iw / ih;
+  const canvasAspect = cw / ch;
+  let width;
+  let height;
+  if (imageAspect > canvasAspect) {
+    width = cw;
+    height = cw / imageAspect;
+  } else {
+    height = ch;
+    width = ch * imageAspect;
+  }
+  width = Math.min(width, cw);
+  height = Math.min(height, ch);
+  return { bounds: { width, height }, frame: { x: cw / 2, y: ch / 2 } };
+}
+var CanvasUnavailableError = class extends Error {
+  constructor() {
+    super(
+      "The '@napi-rs/canvas' rasterizer could not be loaded.\nThis package ships prebuilt platform binaries \u2014 no system libraries needed.\nTry reinstalling dependencies (e.g. `npm install`) to fetch the binary for this platform."
+    );
+    this.name = "CanvasUnavailableError";
+  }
+};
+async function loadCanvasModule() {
+  if (typeof createCanvas !== "function" || typeof loadImage !== "function") {
+    throw new CanvasUnavailableError();
+  }
+  return {
+    createCanvas,
+    loadImage
+  };
+}
+function resolveExportDimensions(docWidth, docHeight, width, height) {
+  if (width !== void 0 && height !== void 0) {
+    return { width, height };
+  }
+  if (width !== void 0) {
+    const h = Math.max(1, Math.round(width * docHeight / docWidth));
+    return { width, height: h };
+  }
+  if (height !== void 0) {
+    const w = Math.max(1, Math.round(height * docWidth / docHeight));
+    return { width: w, height };
+  }
+  return { width: docWidth, height: docHeight };
+}
+async function preloadImages(doc, loadImage2) {
+  const { ImageCache: ImageCache2 } = await import("./dist-M67UZGFQ.js");
+  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 { imageCache: new ImageCache2(), loaded: /* @__PURE__ */ new Map() };
+  }
+  const preloaded = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...sources].map(async (src) => {
+      try {
+        preloaded.set(src, await loadImage2(src));
+      } catch {
+      }
+    })
+  );
+  const imageCache = new ImageCache2({
+    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((resolve14) => process.nextTick(resolve14));
+  return { imageCache, loaded: preloaded };
+}
+async function renderDocumentToPng(doc, opts = {}) {
+  const stateNames = Object.keys(doc.states);
+  if (stateNames.length === 0) {
+    throw new Error("Document has no states");
+  }
+  const stateName = opts.state ?? stateNames[0];
+  if (!doc.states[stateName]) {
+    throw new Error(`State "${stateName}" not found. Available: ${stateNames.join(", ")}`);
+  }
+  const frameNumber = opts.frame ?? 0;
+  if (!Number.isInteger(frameNumber) || frameNumber < 0) {
+    throw new Error(`Invalid frame number: ${frameNumber}`);
+  }
+  const duration = doc.states[stateName].duration;
+  if (frameNumber >= duration) {
+    throw new Error(
+      `Frame ${frameNumber} is out of range for state "${stateName}" (duration ${duration})`
+    );
+  }
+  const { createCanvas: createCanvas2, loadImage: loadImage2 } = await loadCanvasModule();
+  const { renderFrame: renderFrame2 } = await import("./dist-M67UZGFQ.js");
+  const { imageCache, loaded } = await preloadImages(doc, loadImage2);
+  let renderDoc = doc;
+  if (opts.refitImageBounds && loaded.size > 0) {
+    renderDoc = {
+      ...doc,
+      layers: doc.layers.map((layer) => {
+        if (layer.visual.type !== "image") return layer;
+        const iv = layer.visual;
+        const src = iv.src ?? (iv.assetId ? doc.assets?.[iv.assetId]?.src : void 0);
+        const natural = src ? loaded.get(src) : void 0;
+        if (!natural || !natural.width || !natural.height) return layer;
+        const fit = opts.refitImageBounds({ canvas: doc.canvas, natural });
+        return { ...layer, bounds: fit.bounds, frame: fit.frame };
+      })
+    };
+  }
+  const { width: outW, height: outH } = resolveExportDimensions(
+    renderDoc.canvas.width,
+    renderDoc.canvas.height,
+    opts.width,
+    opts.height
+  );
+  const resolved = resolveFrame(renderDoc, stateName, frameNumber);
+  const cvs = createCanvas2(outW, outH);
+  const ctx = cvs.getContext("2d");
+  const sx = outW / renderDoc.canvas.width;
+  const sy = outH / renderDoc.canvas.height;
+  if (sx !== 1 || sy !== 1) ctx.scale(sx, sy);
+  renderFrame2(ctx, resolved, renderDoc, imageCache);
+  return cvs.toBuffer("image/png");
+}
+
+// src/commands/carousel.ts
+import { readdirSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, statSync } from "fs";
+import { resolve as resolve5, join as join4, basename as basename2, extname as extname2, dirname, sep } from "path";
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
+var DEFAULT_CANVAS = 1080;
+function expandInputs(pattern) {
+  const abs = resolve5(pattern);
+  let isDir = false;
+  try {
+    isDir = statSync(abs).isDirectory();
+  } catch {
+    isDir = false;
+  }
+  if (isDir) {
+    return listImages(abs);
+  }
+  const dir = dirname(abs);
+  const base = basename2(abs);
+  if (base.includes("*")) {
+    const matcher = globToRegExp(base);
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return [];
+    }
+    return entries.filter((name) => matcher.test(name) && isImageFile(name)).map((name) => join4(dir, name)).sort();
+  }
+  return isImageFile(base) ? [abs] : [];
+}
+function listImages(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return entries.filter(isImageFile).map((name) => join4(dir, name)).sort();
+}
+function isImageFile(name) {
+  return IMAGE_EXTS.has(extname2(name).toLowerCase());
+}
+function globToRegExp(glob) {
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const pattern = escaped.replace(/\*/g, `[^${sep === "\\" ? "\\\\" : sep}]*`).replace(/\?/g, ".");
+  return new RegExp(`^${pattern}$`);
+}
+function composeCarouselFrameDoc(args) {
+  const { imagePath, index, total, width, height, recipe } = args;
+  const canvas = { width, height };
+  const fit = fitImageToCanvas(canvas, { width: 0, height: 0 });
+  const assetId = "carousel-image-asset";
+  const baseDoc = {
+    version: "1.0",
+    name: `carousel-${index}`,
+    canvas: { width, height, fps: 30, background: args.background ?? "#000000" },
+    assets: { [assetId]: { type: "image", src: imagePath } },
+    layers: [
+      {
+        id: "carousel-image",
+        visual: { type: "image", assetId, src: imagePath },
+        frame: fit.frame,
+        bounds: fit.bounds,
+        anchorPoint: { x: 0.5, y: 0.5 },
+        opacity: 1
+      }
+    ],
+    states: { default: { duration: 1, deltas: [] } }
+  };
+  return applyRecipeToOverlay(baseDoc, recipe, { currentIndex: index, totalCount: total });
+}
+function carouselFileName(index, total, imagePath) {
+  const padWidth = Math.max(2, String(total).length);
+  const prefix = String(index).padStart(padWidth, "0");
+  const ext = extname2(imagePath);
+  const stem = basename2(imagePath, ext);
+  return `${prefix}-${stem}.png`;
+}
+function parseDim(raw, name) {
+  if (raw === void 0) return void 0;
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n <= 0) {
+    console.error(`Invalid --${name}: ${raw}`);
+    process.exit(1);
+  }
+  return n;
+}
+function carouselCommand(program) {
+  program.command("carousel <recipe>").description(
+    "Batch-compose a folder of images into recipe-overlaid PNGs. Each image becomes a fit-to-canvas post with the recipe's handle + page-number ('i/N') overlays, written to --out-dir as zero-padded PNGs."
+  ).requiredOption("-i, --inputs <glob>", "Input images: a directory, file, or single-segment *-glob").requiredOption("-d, --out-dir <dir>", "Destination directory for composed PNGs").option("--width <number>", "Canvas width (px)", String(DEFAULT_CANVAS)).option("--height <number>", "Canvas height (px)", String(DEFAULT_CANVAS)).option("-f, --frame <number>", "Frame to render (defaults to 0)", "0").action(async (recipeRef, options) => {
+    let recipe;
+    try {
+      const loaded = loadRecipe(recipeRef);
+      recipe = loaded.recipe;
+      console.log(`Loaded recipe ${loaded.path}`);
+      for (const w of loaded.warnings) console.log(`  \u26A0  ${w}`);
+    } catch (err) {
+      console.error(`atelier carousel: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+      return;
+    }
+    const inputs = expandInputs(options.inputs);
+    if (inputs.length === 0) {
+      console.error(
+        `atelier carousel: no image files matched --inputs "${options.inputs}" (accepted: ${[...IMAGE_EXTS].join(", ")})`
+      );
+      process.exit(1);
+      return;
+    }
+    const width = parseDim(options.width, "width") ?? DEFAULT_CANVAS;
+    const height = parseDim(options.height, "height") ?? DEFAULT_CANVAS;
+    const frame = parseInt(options.frame, 10);
+    if (isNaN(frame) || frame < 0) {
+      console.error(`Invalid frame number: ${options.frame}`);
+      process.exit(1);
+      return;
+    }
+    const outDir = resolve5(options.outDir);
+    try {
+      mkdirSync3(outDir, { recursive: true });
+    } catch (err) {
+      console.error(`atelier carousel: cannot create out-dir ${outDir}: ${err.message}`);
+      process.exit(1);
+      return;
+    }
+    const total = inputs.length;
+    console.log(`Composing ${total} image${total === 1 ? "" : "s"} \u2192 ${outDir}`);
+    try {
+      for (let n = 0; n < total; n++) {
+        const index = n + 1;
+        const imagePath = inputs[n];
+        const doc = composeCarouselFrameDoc({
+          imagePath,
+          index,
+          total,
+          width,
+          height,
+          recipe
+        });
+        const buffer = await renderDocumentToPng(doc, {
+          frame,
+          // Re-fit the image to the canvas using real natural dims once decoded.
+          refitImageBounds: ({ canvas, natural }) => fitImageToCanvas(canvas, natural)
+        });
+        const outName = carouselFileName(index, total, imagePath);
+        writeFileSync3(join4(outDir, outName), buffer);
+        console.log(`  [${index}/${total}] ${basename2(imagePath)} \u2192 ${outName}`);
+      }
+    } catch (err) {
+      if (err instanceof CanvasUnavailableError) {
+        console.error(err.message);
+        process.exit(1);
+        return;
+      }
+      console.error(`atelier carousel: ${err instanceof Error ? err.message : err}`);
+      process.exit(1);
+      return;
+    }
+    console.log(`
+Done. ${total} image${total === 1 ? "" : "s"} \u2192 ${outDir}`);
+  });
+}
+
+// src/commands/info.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve6 } 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 = resolve6(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 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 readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve7 } 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 = resolve7(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 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) {
+            writeFileSync4(resolve7(options.output), json, "utf-8");
+          } else {
+            console.log(json);
+          }
+        } else {
+          const { createCanvas: createCanvas2 } = await import("@napi-rs/canvas");
+          const { renderFrame: renderFrame2 } = await import("./dist-M67UZGFQ.js");
+          const cvs = createCanvas2(doc.canvas.width, doc.canvas.height);
+          const ctx = cvs.getContext("2d");
+          renderFrame2(ctx, resolved, doc);
+          const buffer = cvs.toBuffer("image/png");
+          if (options.output) {
+            writeFileSync4(resolve7(options.output), buffer);
+          } else {
+            process.stdout.write(buffer);
+          }
+        }
+      } catch (err) {
+        console.error(
+          err.message
+        );
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/render-pipeline.ts
+import { spawn as spawn3 } from "child_process";
+async function checkFfmpeg() {
+  return new Promise((resolve14) => {
+    const proc = spawn3("ffmpeg", ["-version"], { stdio: "pipe" });
+    proc.on("error", () => resolve14(false));
+    proc.on("close", (code) => resolve14(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 preloadImages2(doc, loadImage2) {
+  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 loadImage2(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((resolve14) => process.nextTick(resolve14));
+  return imageCache;
+}
+async function renderDocument(doc, opts) {
+  const canvasModuleName = "canvas";
+  let createCanvas2;
+  let loadImage2;
+  try {
+    const canvasModule = await import(
+      /* webpackIgnore: true */
+      canvasModuleName
+    );
+    createCanvas2 = canvasModule.createCanvas;
+    loadImage2 = 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 preloadImages2(doc, loadImage2);
+  const canvas = createCanvas2(width, height);
+  const ctx = canvas.getContext("2d");
+  const ffmpegArgs = buildFfmpegArgs(width, height, fps, format, output);
+  const ffmpeg = spawn3("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(
+          (resolve14) => ffmpeg.stdin.once("drain", resolve14)
+        );
+      }
+      frameIndex++;
+      onProgress?.({
+        frame: frameIndex,
+        totalFrames,
+        state: stateName,
+        percent: Math.round(frameIndex / totalFrames * 100)
+      });
+    }
+  }
+  ffmpeg.stdin.end();
+  const exitCode = await new Promise((resolve14) => {
+    ffmpeg.on("close", resolve14);
+  });
+  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 readFileSync6 } from "fs";
+import { resolve as resolve8, basename as basename3, extname as extname3 } from "path";
+function readAndParse3(file) {
+  const absPath = resolve8(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 inferFormat(output) {
+  if (!output) return "mp4";
+  const ext = extname3(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 = basename3(file, extname3(file));
+      const output = options.output ?? `${inputName}.${format}`;
+      const startTime = Date.now();
+      try {
+        const result = await renderDocument(doc, {
+          output: resolve8(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 readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve9 } 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 = resolve9(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 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) {
+          writeFileSync5(resolve9(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 readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve10 } 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 = resolve10(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 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) {
+          writeFileSync6(resolve10(options.output), output, "utf-8");
+        } else {
+          console.log(output);
+        }
+      } catch (err) {
+        console.error(err.message);
+        process.exit(1);
+      }
+    }
+  );
+}
+
+// src/commands/export-image.ts
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve11 } from "path";
+function readAndParse6(file) {
+  const absPath = resolve11(file);
+  let content;
+  try {
+    content = readFileSync9(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 parseDim2(raw, name) {
+  if (raw === void 0) return void 0;
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n <= 0) {
+    console.error(`Invalid --${name}: ${raw}`);
+    process.exit(1);
+  }
+  return n;
+}
+function exportImageCommand(program) {
+  program.command("export-image <file>").description(
+    "Export a single frame as a PNG image. Aspect-preserving when only one of --width/--height is set; if both are set the renderer uses both verbatim (may squash)."
+  ).requiredOption("-o, --out <path>", "Output PNG file path").option("-s, --state <name>", "State name (defaults to first state)").option("-f, --frame <number>", "Frame number (defaults to 0)", "0").option("--width <number>", "Override output width (px)").option("--height <number>", "Override output height (px)").action(async (file, options) => {
+    const doc = readAndParse6(file);
+    const frameNumber = parseInt(options.frame, 10);
+    if (isNaN(frameNumber) || frameNumber < 0) {
+      console.error(`Invalid frame number: ${options.frame}`);
+      process.exit(1);
+      return;
+    }
+    const width = parseDim2(options.width, "width");
+    const height = parseDim2(options.height, "height");
+    try {
+      const buffer = await renderDocumentToPng(doc, {
+        state: options.state,
+        frame: frameNumber,
+        width,
+        height
+      });
+      writeFileSync7(resolve11(options.out), buffer);
+    } catch (err) {
+      if (err instanceof CanvasUnavailableError) {
+        console.error(err.message);
+        process.exit(1);
+        return;
+      }
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/assets.ts
+import { readFileSync as readFileSync10 } from "fs";
+import { resolve as resolve12 } 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 readAndParse7(file) {
+  const absPath = resolve12(file);
+  let content;
+  try {
+    content = readFileSync10(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 = readAndParse7(file);
+    const assets = getAssets(doc);
+    console.log(formatAssets(assets));
+  });
+}
+
+// src/commands/variables.ts
+import { readFileSync as readFileSync11 } from "fs";
+import { resolve as resolve13 } 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 readAndParse8(file) {
+  const absPath = resolve13(file);
+  let content;
+  try {
+    content = readFileSync11(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 = readAndParse8(file);
+    const info = getVariables(doc);
+    console.log(formatVariables(info));
+  });
+}
+
+export {
+  validateVideoLayer,
+  parseAtelier,
+  serializeAtelier,
+  validateFile,
+  validateCommand,
+  VIDEO_PROJECT_VERSION,
+  VIDEO_CUTLIST_VERSION,
+  VIDEO_TRANSCRIPT_VERSION,
+  effectiveSpan,
+  createVideoProject,
+  loadVideoProject,
+  readCutList,
+  writeCutList,
+  readTranscript,
+  writeTranscript,
+  readComposition,
+  writeComposition,
+  rewriteCutLayers,
+  RECIPE_VERSION,
+  resolveRecipePath,
+  loadRecipe,
+  scaffoldRecipeYaml,
+  applyRecipeToTrimOptions,
+  applyRecipeToCaptionOptions,
+  applyRecipeToTranscribeOptions,
+  renderRecipeWithDefaults,
+  recipeToYaml,
+  trimProject,
+  trimCommand,
+  probeWhisper,
+  runWhisperCpp,
+  parseWhisperCppJson,
+  flattenWords,
+  groupIntoPhrases,
+  mergeTranscriptWithExisting,
+  applyTextEdit,
+  applyBatchReplace,
+  applyHide,
+  applyAdd,
+  applyMerge,
+  applySplit,
+  buildCaptionLayers,
+  rewriteCaptionLayers,
+  transcribeProject,
+  transcribeCommand,
+  transcriptCommand,
+  captionsCommand,
+  recipeCommand,
+  applyRecipeCommand,
+  fitImageToCanvas,
+  CanvasUnavailableError,
+  loadCanvasModule,
+  resolveExportDimensions,
+  renderDocumentToPng,
+  expandInputs,
+  composeCarouselFrameDoc,
+  carouselFileName,
+  carouselCommand,
+  getInfo,
+  infoCommand,
+  resolveStill,
+  stillCommand,
+  checkFfmpeg,
+  buildFfmpegArgs,
+  renderDocument,
+  renderCommand,
+  exportSvgCommand,
+  exportLottieCommand,
+  exportImageCommand,
+  getAssets,
+  assetsCommand,
+  getVariables,
+  variablesCommand
+};
+//# sourceMappingURL=chunk-5QQESXI6.js.map