@a-company/atelier 0.1.0

package/dist/mcp.js

@@ -0,0 +1,1784 @@
+#!/usr/bin/env node
+
+// ../mcp/src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../mcp/src/store.ts
+var counter = 0;
+function generateId() {
+  counter++;
+  return `doc_${Date.now()}_${counter}`;
+}
+var DocumentStore = class {
+  docs = /* @__PURE__ */ new Map();
+  /** Create a new document entry. Returns the assigned ID. */
+  create(doc, id) {
+    const docId = id ?? generateId();
+    if (this.docs.has(docId)) {
+      throw new Error(`Document "${docId}" already exists`);
+    }
+    this.docs.set(docId, doc);
+    return docId;
+  }
+  /** Get a document by ID. */
+  get(id) {
+    return this.docs.get(id);
+  }
+  /** Set (overwrite) a document by ID. */
+  set(id, doc) {
+    this.docs.set(id, doc);
+  }
+  /** Delete a document by ID. Returns true if it existed. */
+  delete(id) {
+    return this.docs.delete(id);
+  }
+  /** Check if a document exists. */
+  has(id) {
+    return this.docs.has(id);
+  }
+  /** List all document IDs and their names. */
+  list() {
+    const result = [];
+    for (const [id, doc] of this.docs) {
+      result.push({ id, name: doc.name, canvas: doc.canvas });
+    }
+    return result;
+  }
+  /** Clear all documents (useful for testing). */
+  clear() {
+    this.docs.clear();
+  }
+};
+
+// ../mcp/src/tools/document.ts
+import { z as z14 } from "zod";
+
+// ../schema/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
+import { z as z10 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
+import { z as z13 } from "zod";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+var PixelSchema = z.number();
+var PercentageSchema = z.string().regex(/^-?\d+(\.\d+)?%$/, {
+  message: 'Percentage must be a number followed by %, e.g. "50%"'
+});
+var UnitValueSchema = z.union([PixelSchema, PercentageSchema]);
+var FrameSchema = z2.object({
+  x: UnitValueSchema,
+  y: UnitValueSchema
+});
+var BoundsSchema = z2.object({
+  width: UnitValueSchema,
+  height: UnitValueSchema
+});
+var AnchorPointSchema = z2.object({
+  x: z2.number().min(0).max(1),
+  y: z2.number().min(0).max(1)
+});
+var RGBAColorSchema = z3.object({
+  r: z3.number().min(0).max(255),
+  g: z3.number().min(0).max(255),
+  b: z3.number().min(0).max(255),
+  a: z3.number().min(0).max(1)
+});
+var HSLAColorSchema = z3.object({
+  h: z3.number().min(0).max(360),
+  s: z3.number().min(0).max(100),
+  l: z3.number().min(0).max(100),
+  a: z3.number().min(0).max(1)
+});
+var HexColorSchema = z3.string().regex(/^#([0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+  message: "Color must be a hex string: #RGB, #RGBA, #RRGGBB, or #RRGGBBAA"
+});
+var ColorSchema = z3.union([RGBAColorSchema, HSLAColorSchema, HexColorSchema]);
+var PathPointSchema = z4.object({
+  x: z4.number(),
+  y: z4.number(),
+  in: z4.object({ x: z4.number(), y: z4.number() }).optional(),
+  out: z4.object({ x: z4.number(), y: z4.number() }).optional()
+});
+var RectShapeSchema = z4.object({
+  type: z4.literal("rect"),
+  cornerRadius: z4.union([
+    z4.number().min(0),
+    z4.tuple([z4.number().min(0), z4.number().min(0), z4.number().min(0), z4.number().min(0)])
+  ]).optional()
+});
+var EllipseShapeSchema = z4.object({
+  type: z4.literal("ellipse")
+});
+var PathShapeSchema = z4.object({
+  type: z4.literal("path"),
+  points: z4.array(PathPointSchema).min(2, "Path must have at least 2 points"),
+  closed: z4.boolean().optional()
+});
+var ShapeSchema = z4.discriminatedUnion("type", [
+  RectShapeSchema,
+  EllipseShapeSchema,
+  PathShapeSchema
+]);
+var GradientStopSchema = z4.object({
+  offset: z4.number().min(0).max(1),
+  color: ColorSchema
+});
+var SolidFillSchema = z4.object({
+  type: z4.literal("solid"),
+  color: ColorSchema
+});
+var LinearGradientFillSchema = z4.object({
+  type: z4.literal("linear-gradient"),
+  angle: z4.number(),
+  stops: z4.array(GradientStopSchema).min(2, "Gradient needs at least 2 stops")
+});
+var RadialGradientFillSchema = z4.object({
+  type: z4.literal("radial-gradient"),
+  center: z4.object({ x: UnitValueSchema, y: UnitValueSchema }),
+  radius: UnitValueSchema,
+  stops: z4.array(GradientStopSchema).min(2, "Gradient needs at least 2 stops")
+});
+var FillSchema = z4.discriminatedUnion("type", [
+  SolidFillSchema,
+  LinearGradientFillSchema,
+  RadialGradientFillSchema
+]);
+var StrokeSchema = z4.object({
+  color: ColorSchema,
+  width: z4.number().min(0),
+  dash: z4.array(z4.number().min(0)).optional(),
+  lineCap: z4.enum(["butt", "round", "square"]).optional(),
+  lineJoin: z4.enum(["miter", "round", "bevel"]).optional(),
+  strokeStart: z4.number().min(0).max(1).optional(),
+  strokeEnd: z4.number().min(0).max(1).optional()
+});
+var TextStyleSchema = z4.object({
+  fontFamily: z4.string().min(1, "fontFamily is required"),
+  fontSize: z4.number().positive("fontSize must be positive"),
+  fontWeight: z4.union([z4.number(), z4.enum(["normal", "bold"])]).optional(),
+  fontStyle: z4.enum(["normal", "italic"]).optional(),
+  textAlign: z4.enum(["left", "center", "right"]).optional(),
+  lineHeight: z4.number().positive().optional(),
+  letterSpacing: z4.number().optional(),
+  color: ColorSchema
+});
+var LinearEasingSchema = z5.object({ type: z5.literal("linear") });
+var CubicBezierEasingSchema = z5.object({
+  type: z5.literal("cubic-bezier"),
+  x1: z5.number().min(0).max(1),
+  y1: z5.number(),
+  x2: z5.number().min(0).max(1),
+  y2: z5.number()
+});
+var SpringEasingSchema = z5.object({
+  type: z5.literal("spring"),
+  mass: z5.number().positive().optional(),
+  stiffness: z5.number().positive().optional(),
+  damping: z5.number().positive().optional(),
+  velocity: z5.number().optional()
+});
+var StepEasingSchema = z5.object({
+  type: z5.literal("step"),
+  steps: z5.number().int().positive(),
+  position: z5.enum(["start", "end"]).optional()
+});
+var EasingPresetSchema = z5.enum(["ease-in", "ease-out", "ease-in-out"]);
+var EasingSchema = z5.union([
+  LinearEasingSchema,
+  CubicBezierEasingSchema,
+  SpringEasingSchema,
+  StepEasingSchema,
+  EasingPresetSchema
+]);
+var ShadowSchema = z6.object({
+  color: ColorSchema,
+  blur: z6.number().min(0),
+  offsetX: z6.number().optional(),
+  offsetY: z6.number().optional()
+});
+var ShapeVisualSchema = z7.object({
+  type: z7.literal("shape"),
+  shape: ShapeSchema,
+  fill: FillSchema.optional(),
+  stroke: StrokeSchema.optional()
+});
+var TextVisualSchema = z7.object({
+  type: z7.literal("text"),
+  content: z7.string(),
+  style: TextStyleSchema
+});
+var ImageVisualSchema = z7.object({
+  type: z7.literal("image"),
+  assetId: z7.string().min(1, "assetId is required"),
+  src: z7.string().optional()
+});
+var GroupVisualSchema = z7.object({
+  type: z7.literal("group")
+});
+var RefVisualSchema = z7.object({
+  type: z7.literal("ref"),
+  src: z7.string().min(1, "src is required")
+});
+var VisualSchema = z7.discriminatedUnion("type", [
+  ShapeVisualSchema,
+  TextVisualSchema,
+  ImageVisualSchema,
+  GroupVisualSchema,
+  RefVisualSchema
+]);
+var LayerSchema = z7.object({
+  id: z7.string().min(1, "Layer id is required"),
+  description: z7.string().optional(),
+  tags: z7.array(z7.string()).optional(),
+  visual: VisualSchema,
+  frame: FrameSchema,
+  bounds: BoundsSchema,
+  anchorPoint: AnchorPointSchema.optional(),
+  parentId: z7.string().optional(),
+  opacity: z7.number().min(0).max(1).optional(),
+  rotation: z7.number().optional(),
+  scale: z7.object({ x: z7.number(), y: z7.number() }).optional(),
+  visible: z7.boolean().optional(),
+  shadow: ShadowSchema.optional()
+});
+var AnimatablePropertySchema = z8.enum([
+  "frame.x",
+  "frame.y",
+  "bounds.width",
+  "bounds.height",
+  "opacity",
+  "rotation",
+  "scale.x",
+  "scale.y",
+  "anchorPoint.x",
+  "anchorPoint.y",
+  "visual.shape.cornerRadius",
+  "visual.fill.color",
+  "visual.stroke.color",
+  "visual.stroke.width",
+  "visual.stroke.start",
+  "visual.stroke.end",
+  "visual.style.fontSize",
+  "visual.style.color",
+  "shadow.color",
+  "shadow.blur",
+  "shadow.offsetX",
+  "shadow.offsetY"
+]);
+var FrameRangeSchema = z8.tuple([
+  z8.number().int().min(0, "Frame start must be >= 0"),
+  z8.number().int().min(0, "Frame end must be >= 0")
+]).refine(([start, end]) => end >= start, {
+  message: "Frame range end must be >= start"
+});
+var DeltaSchema = z8.object({
+  id: z8.string().optional(),
+  name: z8.string().optional(),
+  layer: z8.string().min(1, "Delta must reference a layer id"),
+  property: AnimatablePropertySchema,
+  range: FrameRangeSchema,
+  from: z8.unknown(),
+  to: z8.unknown(),
+  easing: EasingSchema.optional(),
+  description: z8.string().optional(),
+  tags: z8.array(z8.string()).optional()
+});
+var StateSchema = z9.object({
+  description: z9.string().optional(),
+  tags: z9.array(z9.string()).optional(),
+  duration: z9.number().int().positive("State duration must be a positive integer (frames)"),
+  deltas: z9.array(DeltaSchema)
+});
+var PresetDeltaSchema = z10.object({
+  property: AnimatablePropertySchema,
+  offset: z10.tuple([z10.number().int().min(0), z10.number().int().min(0)]).optional(),
+  from: z10.unknown(),
+  to: z10.unknown(),
+  easing: EasingSchema.optional()
+});
+var PresetSchema = z10.object({
+  description: z10.string().optional(),
+  tags: z10.array(z10.string()).optional(),
+  deltas: z10.array(PresetDeltaSchema).min(1, "Preset must have at least one delta")
+});
+var VariableTypeSchema = z11.enum(["string", "number", "color", "asset", "boolean"]);
+var VariableSchema = z11.object({
+  type: VariableTypeSchema,
+  default: z11.unknown().optional(),
+  description: z11.string().optional()
+});
+var AssetTypeSchema = z12.enum(["image", "svg", "font", "animation"]);
+var AssetSchema = z12.object({
+  type: AssetTypeSchema,
+  src: z12.string().min(1, "Asset src is required"),
+  description: z12.string().optional()
+});
+var CanvasSchema = z13.object({
+  width: z13.number().int().positive("Canvas width must be a positive integer"),
+  height: z13.number().int().positive("Canvas height must be a positive integer"),
+  fps: z13.number().int().positive("FPS must be a positive integer"),
+  background: z13.string().optional()
+});
+var AtelierDocumentSchema = z13.object({
+  version: z13.string().min(1, "Version is required"),
+  name: z13.string().min(1, "Animation name is required"),
+  description: z13.string().optional(),
+  tags: z13.array(z13.string()).optional(),
+  canvas: CanvasSchema,
+  variables: z13.record(z13.string(), VariableSchema).optional(),
+  assets: z13.record(z13.string(), AssetSchema).optional(),
+  presets: z13.record(z13.string(), PresetSchema).optional(),
+  layers: z13.array(LayerSchema),
+  states: z13.record(z13.string(), StateSchema)
+});
+function formatErrors(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join(".") || "(root)",
+    message: issue.message
+  }));
+}
+function validateDocument(input) {
+  const result = AtelierDocumentSchema.safeParse(input);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, errors: formatErrors(result.error) };
+}
+function parseAtelier(yamlString) {
+  let parsed;
+  try {
+    parsed = yamlParse(yamlString);
+  } catch (err9) {
+    return {
+      success: false,
+      errors: [{ path: "(yaml)", message: `YAML parse error: ${err9.message}` }]
+    };
+  }
+  return validateDocument(parsed);
+}
+function serializeAtelier(doc) {
+  return yamlStringify(doc, { indent: 2 });
+}
+
+// ../mcp/src/tools/document.ts
+function getDoc(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+function register(server, store) {
+  server.tool(
+    "atelier_create",
+    "Create a new Atelier animation document with canvas settings",
+    {
+      name: z14.string().describe("Animation name"),
+      width: z14.number().positive().describe("Canvas width in pixels"),
+      height: z14.number().positive().describe("Canvas height in pixels"),
+      fps: z14.number().positive().int().describe("Frames per second"),
+      background: z14.string().optional().describe("Background color (hex string)"),
+      description: z14.string().optional().describe("Animation description"),
+      tags: z14.array(z14.string()).optional().describe("Tags for categorization")
+    },
+    async ({ name, width, height, fps, background, description, tags }) => {
+      const doc = {
+        version: "1.0",
+        name,
+        canvas: { width, height, fps, ...background ? { background } : {} },
+        layers: [],
+        states: {},
+        ...description ? { description } : {},
+        ...tags ? { tags } : {}
+      };
+      const validation = validateDocument(doc);
+      if (!validation.success) {
+        return err(`Validation failed: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+      }
+      const id = store.create(doc);
+      return ok({ id, name: doc.name, canvas: doc.canvas });
+    }
+  );
+  server.tool(
+    "atelier_info",
+    "Get summary information about an Atelier document",
+    {
+      id: z14.string().describe("Document ID")
+    },
+    async ({ id }) => {
+      const result = getDoc(store, id);
+      if ("error" in result) return err(result.error);
+      const { doc } = result;
+      const stateNames = Object.keys(doc.states);
+      const totalDuration = stateNames.reduce(
+        (sum, name) => sum + doc.states[name].duration,
+        0
+      );
+      return ok({
+        name: doc.name,
+        description: doc.description,
+        tags: doc.tags,
+        canvas: doc.canvas,
+        layerCount: doc.layers.length,
+        stateNames,
+        totalDuration,
+        presetNames: doc.presets ? Object.keys(doc.presets) : []
+      });
+    }
+  );
+  server.tool(
+    "atelier_load",
+    "Load an Atelier document from a YAML string",
+    {
+      id: z14.string().optional().describe("Custom document ID (auto-generated if omitted)"),
+      yaml: z14.string().describe("YAML string representing an Atelier document")
+    },
+    async ({ id, yaml }) => {
+      const parsed = parseAtelier(yaml);
+      if (!parsed.success) {
+        return err(`Parse/validation failed: ${parsed.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+      }
+      const docId = store.create(parsed.data, id);
+      return ok({ id: docId, name: parsed.data.name });
+    }
+  );
+  server.tool(
+    "atelier_export",
+    "Export an Atelier document as a YAML string",
+    {
+      id: z14.string().describe("Document ID")
+    },
+    async ({ id }) => {
+      const result = getDoc(store, id);
+      if ("error" in result) return err(result.error);
+      const yaml = serializeAtelier(result.doc);
+      return { content: [{ type: "text", text: yaml }] };
+    }
+  );
+  server.tool(
+    "atelier_list",
+    "List all Atelier documents in the store",
+    {},
+    async () => {
+      const docs = store.list();
+      return ok({ documents: docs, count: docs.length });
+    }
+  );
+}
+
+// ../mcp/src/tools/layers.ts
+import { z as z15 } from "zod";
+function getDoc2(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok2(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err2(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+var VisualInputSchema = z15.object({
+  type: z15.enum(["shape", "text", "image", "group", "ref"]).describe("Visual type"),
+  // shape visual fields
+  shape: z15.object({
+    type: z15.enum(["rect", "ellipse", "path"]),
+    cornerRadius: z15.union([z15.number(), z15.tuple([z15.number(), z15.number(), z15.number(), z15.number()])]).optional(),
+    points: z15.array(z15.object({
+      x: z15.number(),
+      y: z15.number(),
+      in: z15.object({ x: z15.number(), y: z15.number() }).optional(),
+      out: z15.object({ x: z15.number(), y: z15.number() }).optional()
+    })).optional(),
+    closed: z15.boolean().optional()
+  }).optional(),
+  fill: z15.record(z15.unknown()).optional(),
+  stroke: z15.record(z15.unknown()).optional(),
+  // text visual fields
+  content: z15.string().optional(),
+  style: z15.record(z15.unknown()).optional(),
+  // image visual fields
+  assetId: z15.string().optional(),
+  // ref visual fields
+  src: z15.string().optional()
+}).describe("Visual content definition");
+function register2(server, store) {
+  server.tool(
+    "atelier_add_layer",
+    "Add a new layer to an Atelier document",
+    {
+      id: z15.string().describe("Document ID"),
+      layerId: z15.string().describe("Unique layer ID"),
+      visual: VisualInputSchema.describe("Visual content definition"),
+      x: z15.union([z15.number(), z15.string()]).describe("X position (pixels or percentage)"),
+      y: z15.union([z15.number(), z15.string()]).describe("Y position (pixels or percentage)"),
+      width: z15.union([z15.number(), z15.string()]).describe("Width (pixels or percentage)"),
+      height: z15.union([z15.number(), z15.string()]).describe("Height (pixels or percentage)"),
+      description: z15.string().optional().describe("Layer description"),
+      tags: z15.array(z15.string()).optional().describe("Tags"),
+      opacity: z15.number().min(0).max(1).optional().describe("Opacity 0-1"),
+      rotation: z15.number().optional().describe("Rotation in degrees"),
+      parentId: z15.string().optional().describe("Parent layer ID for transform inheritance"),
+      anchorPoint: z15.object({ x: z15.number(), y: z15.number() }).optional().describe("Anchor point (0-1 normalized)"),
+      scale: z15.object({ x: z15.number(), y: z15.number() }).optional().describe("Scale factors"),
+      visible: z15.boolean().optional().describe("Whether layer is visible")
+    },
+    async ({ id, layerId, visual, x, y, width, height, description, tags, opacity, rotation, parentId, anchorPoint, scale, visible }) => {
+      const result = getDoc2(store, id);
+      if ("error" in result) return err2(result.error);
+      const { doc } = result;
+      if (doc.layers.some((l) => l.id === layerId)) {
+        return err2(`Layer "${layerId}" already exists in document "${id}"`);
+      }
+      if (parentId && !doc.layers.some((l) => l.id === parentId)) {
+        return err2(`Parent layer "${parentId}" not found`);
+      }
+      const layer = {
+        id: layerId,
+        visual,
+        frame: { x, y },
+        bounds: { width, height },
+        ...description != null ? { description } : {},
+        ...tags ? { tags } : {},
+        ...opacity != null ? { opacity } : {},
+        ...rotation != null ? { rotation } : {},
+        ...parentId ? { parentId } : {},
+        ...anchorPoint ? { anchorPoint } : {},
+        ...scale ? { scale } : {},
+        ...visible != null ? { visible } : {}
+      };
+      doc.layers.push(layer);
+      return ok2({ layerId, index: doc.layers.length - 1 });
+    }
+  );
+  server.tool(
+    "atelier_edit_layer",
+    "Edit properties of an existing layer",
+    {
+      id: z15.string().describe("Document ID"),
+      layerId: z15.string().describe("Layer ID to edit"),
+      x: z15.union([z15.number(), z15.string()]).optional().describe("New X position"),
+      y: z15.union([z15.number(), z15.string()]).optional().describe("New Y position"),
+      width: z15.union([z15.number(), z15.string()]).optional().describe("New width"),
+      height: z15.union([z15.number(), z15.string()]).optional().describe("New height"),
+      description: z15.string().optional().describe("New description"),
+      tags: z15.array(z15.string()).optional().describe("New tags"),
+      opacity: z15.number().min(0).max(1).optional().describe("New opacity"),
+      rotation: z15.number().optional().describe("New rotation"),
+      parentId: z15.string().nullable().optional().describe("New parent layer ID (null to clear)"),
+      anchorPoint: z15.object({ x: z15.number(), y: z15.number() }).optional().describe("New anchor point"),
+      scale: z15.object({ x: z15.number(), y: z15.number() }).optional().describe("New scale"),
+      visible: z15.boolean().optional().describe("New visibility")
+    },
+    async ({ id, layerId, x, y, width, height, description, tags, opacity, rotation, parentId, anchorPoint, scale, visible }) => {
+      const result = getDoc2(store, id);
+      if ("error" in result) return err2(result.error);
+      const { doc } = result;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err2(`Layer "${layerId}" not found`);
+      if (x != null) layer.frame.x = x;
+      if (y != null) layer.frame.y = y;
+      if (width != null) layer.bounds.width = width;
+      if (height != null) layer.bounds.height = height;
+      if (description != null) layer.description = description;
+      if (tags) layer.tags = tags;
+      if (opacity != null) layer.opacity = opacity;
+      if (rotation != null) layer.rotation = rotation;
+      if (parentId !== void 0) {
+        if (parentId === null) {
+          delete layer.parentId;
+        } else {
+          if (!doc.layers.some((l) => l.id === parentId)) return err2(`Parent layer "${parentId}" not found`);
+          layer.parentId = parentId;
+        }
+      }
+      if (anchorPoint) layer.anchorPoint = anchorPoint;
+      if (scale) layer.scale = scale;
+      if (visible != null) layer.visible = visible;
+      return ok2({ layerId, updated: true });
+    }
+  );
+  server.tool(
+    "atelier_remove_layer",
+    "Remove a layer from an Atelier document",
+    {
+      id: z15.string().describe("Document ID"),
+      layerId: z15.string().describe("Layer ID to remove")
+    },
+    async ({ id, layerId }) => {
+      const result = getDoc2(store, id);
+      if ("error" in result) return err2(result.error);
+      const { doc } = result;
+      const index = doc.layers.findIndex((l) => l.id === layerId);
+      if (index === -1) return err2(`Layer "${layerId}" not found`);
+      const warnings = [];
+      for (const [stateName, state] of Object.entries(doc.states)) {
+        const deltaCount = state.deltas.filter((d) => d.layer === layerId).length;
+        if (deltaCount > 0) {
+          warnings.push(`State "${stateName}" has ${deltaCount} delta(s) referencing this layer`);
+        }
+      }
+      const childCount = doc.layers.filter((l) => l.parentId === layerId).length;
+      if (childCount > 0) {
+        warnings.push(`${childCount} child layer(s) reference this layer as parent`);
+      }
+      doc.layers.splice(index, 1);
+      return ok2({ layerId, removed: true, warnings });
+    }
+  );
+  server.tool(
+    "atelier_list_layers",
+    "List all layers in an Atelier document",
+    {
+      id: z15.string().describe("Document ID")
+    },
+    async ({ id }) => {
+      const result = getDoc2(store, id);
+      if ("error" in result) return err2(result.error);
+      const { doc } = result;
+      const layers = doc.layers.map((l, index) => ({
+        index,
+        id: l.id,
+        type: l.visual.type,
+        frame: l.frame,
+        bounds: l.bounds,
+        description: l.description,
+        tags: l.tags,
+        opacity: l.opacity,
+        rotation: l.rotation,
+        parentId: l.parentId,
+        visible: l.visible
+      }));
+      return ok2({ layers, count: layers.length });
+    }
+  );
+  server.tool(
+    "atelier_reorder",
+    "Move a layer to a new position in the layer stack",
+    {
+      id: z15.string().describe("Document ID"),
+      layerId: z15.string().describe("Layer ID to move"),
+      position: z15.number().int().min(0).describe("Target position index (0-based)")
+    },
+    async ({ id, layerId, position }) => {
+      const result = getDoc2(store, id);
+      if ("error" in result) return err2(result.error);
+      const { doc } = result;
+      const currentIndex = doc.layers.findIndex((l) => l.id === layerId);
+      if (currentIndex === -1) return err2(`Layer "${layerId}" not found`);
+      const targetPos = Math.min(position, doc.layers.length - 1);
+      const [layer] = doc.layers.splice(currentIndex, 1);
+      doc.layers.splice(targetPos, 0, layer);
+      return ok2({ layerId, from: currentIndex, to: targetPos });
+    }
+  );
+}
+
+// ../mcp/src/tools/shapes.ts
+import { z as z16 } from "zod";
+function getDoc3(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok3(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err3(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+function register3(server, store) {
+  server.tool(
+    "atelier_set_shape",
+    "Set the shape on a shape-type layer",
+    {
+      id: z16.string().describe("Document ID"),
+      layerId: z16.string().describe("Layer ID (must be a shape visual)"),
+      shape: z16.object({
+        type: z16.enum(["rect", "ellipse", "path"]).describe("Shape type"),
+        cornerRadius: z16.union([
+          z16.number(),
+          z16.tuple([z16.number(), z16.number(), z16.number(), z16.number()])
+        ]).optional().describe("Corner radius (rect only)"),
+        points: z16.array(z16.object({
+          x: z16.number(),
+          y: z16.number(),
+          in: z16.object({ x: z16.number(), y: z16.number() }).optional(),
+          out: z16.object({ x: z16.number(), y: z16.number() }).optional()
+        })).optional().describe("Path points (path only)"),
+        closed: z16.boolean().optional().describe("Whether path is closed (path only)")
+      }).describe("Shape definition")
+    },
+    async ({ id, layerId, shape }) => {
+      const result = getDoc3(store, id);
+      if ("error" in result) return err3(result.error);
+      const { doc } = result;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err3(`Layer "${layerId}" not found`);
+      if (layer.visual.type !== "shape") return err3(`Layer "${layerId}" is type "${layer.visual.type}", not "shape"`);
+      layer.visual.shape = shape;
+      return ok3({ layerId, shape: shape.type });
+    }
+  );
+  server.tool(
+    "atelier_set_fill",
+    "Set the fill on a shape-type layer",
+    {
+      id: z16.string().describe("Document ID"),
+      layerId: z16.string().describe("Layer ID (must be a shape visual)"),
+      fill: z16.object({
+        type: z16.enum(["solid", "linear-gradient", "radial-gradient"]).describe("Fill type"),
+        color: z16.unknown().optional().describe("Color for solid fill (hex string or RGBA/HSLA object)"),
+        angle: z16.number().optional().describe("Angle in degrees (linear-gradient only)"),
+        center: z16.object({
+          x: z16.union([z16.number(), z16.string()]),
+          y: z16.union([z16.number(), z16.string()])
+        }).optional().describe("Center point (radial-gradient only)"),
+        radius: z16.union([z16.number(), z16.string()]).optional().describe("Radius (radial-gradient only)"),
+        stops: z16.array(z16.object({
+          offset: z16.number().min(0).max(1),
+          color: z16.unknown()
+        })).optional().describe("Gradient stops")
+      }).describe("Fill definition")
+    },
+    async ({ id, layerId, fill }) => {
+      const result = getDoc3(store, id);
+      if ("error" in result) return err3(result.error);
+      const { doc } = result;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err3(`Layer "${layerId}" not found`);
+      if (layer.visual.type !== "shape") return err3(`Layer "${layerId}" is type "${layer.visual.type}", not "shape"`);
+      layer.visual.fill = fill;
+      return ok3({ layerId, fillType: fill.type });
+    }
+  );
+  server.tool(
+    "atelier_set_stroke",
+    "Set the stroke on a shape-type layer",
+    {
+      id: z16.string().describe("Document ID"),
+      layerId: z16.string().describe("Layer ID (must be a shape visual)"),
+      stroke: z16.object({
+        color: z16.unknown().describe("Stroke color (hex string or RGBA/HSLA object)"),
+        width: z16.number().positive().describe("Stroke width in pixels"),
+        dash: z16.array(z16.number()).optional().describe("Dash pattern"),
+        lineCap: z16.enum(["butt", "round", "square"]).optional().describe("Line cap style"),
+        lineJoin: z16.enum(["miter", "round", "bevel"]).optional().describe("Line join style")
+      }).describe("Stroke definition")
+    },
+    async ({ id, layerId, stroke }) => {
+      const result = getDoc3(store, id);
+      if ("error" in result) return err3(result.error);
+      const { doc } = result;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err3(`Layer "${layerId}" not found`);
+      if (layer.visual.type !== "shape") return err3(`Layer "${layerId}" is type "${layer.visual.type}", not "shape"`);
+      layer.visual.stroke = stroke;
+      return ok3({ layerId, strokeWidth: stroke.width });
+    }
+  );
+}
+
+// ../mcp/src/tools/states.ts
+import { z as z17 } from "zod";
+function getDoc4(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok4(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err4(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+function register4(server, store) {
+  server.tool(
+    "atelier_add_state",
+    "Add a named animation state to a document",
+    {
+      id: z17.string().describe("Document ID"),
+      stateName: z17.string().describe("State name (e.g. 'intro', 'hover', 'exit')"),
+      duration: z17.number().positive().int().describe("Duration in frames"),
+      description: z17.string().optional().describe("State description"),
+      tags: z17.array(z17.string()).optional().describe("Tags")
+    },
+    async ({ id, stateName, duration, description, tags }) => {
+      const result = getDoc4(store, id);
+      if ("error" in result) return err4(result.error);
+      const { doc } = result;
+      if (doc.states[stateName]) {
+        return err4(`State "${stateName}" already exists`);
+      }
+      doc.states[stateName] = {
+        duration,
+        deltas: [],
+        ...description ? { description } : {},
+        ...tags ? { tags } : {}
+      };
+      return ok4({ stateName, duration });
+    }
+  );
+  server.tool(
+    "atelier_edit_state",
+    "Edit metadata of an existing animation state",
+    {
+      id: z17.string().describe("Document ID"),
+      stateName: z17.string().describe("State name to edit"),
+      duration: z17.number().positive().int().optional().describe("New duration in frames"),
+      description: z17.string().optional().describe("New description"),
+      tags: z17.array(z17.string()).optional().describe("New tags")
+    },
+    async ({ id, stateName, duration, description, tags }) => {
+      const result = getDoc4(store, id);
+      if ("error" in result) return err4(result.error);
+      const { doc } = result;
+      const state = doc.states[stateName];
+      if (!state) return err4(`State "${stateName}" not found`);
+      if (duration != null) state.duration = duration;
+      if (description != null) state.description = description;
+      if (tags) state.tags = tags;
+      return ok4({ stateName, updated: true });
+    }
+  );
+  server.tool(
+    "atelier_remove_state",
+    "Remove an animation state and all its deltas",
+    {
+      id: z17.string().describe("Document ID"),
+      stateName: z17.string().describe("State name to remove")
+    },
+    async ({ id, stateName }) => {
+      const result = getDoc4(store, id);
+      if ("error" in result) return err4(result.error);
+      const { doc } = result;
+      if (!doc.states[stateName]) return err4(`State "${stateName}" not found`);
+      const deltaCount = doc.states[stateName].deltas.length;
+      delete doc.states[stateName];
+      return ok4({ stateName, removed: true, deltasRemoved: deltaCount });
+    }
+  );
+  server.tool(
+    "atelier_list_states",
+    "List all animation states in a document",
+    {
+      id: z17.string().describe("Document ID")
+    },
+    async ({ id }) => {
+      const result = getDoc4(store, id);
+      if ("error" in result) return err4(result.error);
+      const { doc } = result;
+      const states = Object.entries(doc.states).map(([name, state]) => ({
+        name,
+        duration: state.duration,
+        description: state.description,
+        tags: state.tags,
+        deltaCount: state.deltas.length
+      }));
+      return ok4({ states, count: states.length });
+    }
+  );
+}
+
+// ../mcp/src/tools/deltas.ts
+import { z as z18 } from "zod";
+
+// ../math/dist/index.js
+function linear(t) {
+  return t;
+}
+function cubicBezier(x1, y1, x2, y2) {
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    let lo = 0;
+    let hi = 1;
+    let mid = 0;
+    for (let i = 0; i < 20; i++) {
+      mid = (lo + hi) / 2;
+      const x = sampleBezier(x1, x2, mid);
+      if (Math.abs(x - t) < 1e-6) break;
+      if (x < t) lo = mid;
+      else hi = mid;
+    }
+    mid = (lo + hi) / 2;
+    return sampleBezier(y1, y2, mid);
+  };
+}
+function sampleBezier(p1, p2, t) {
+  return 3 * (1 - t) * (1 - t) * t * p1 + 3 * (1 - t) * t * t * p2 + t * t * t;
+}
+var easeIn = cubicBezier(0.42, 0, 1, 1);
+var easeOut = cubicBezier(0, 0, 0.58, 1);
+var easeInOut = cubicBezier(0.42, 0, 0.58, 1);
+function step(steps, position = "end") {
+  return (t) => {
+    if (t <= 0) return position === "start" ? 1 / steps : 0;
+    if (t >= 1) return 1;
+    const s = Math.floor(t * steps);
+    if (position === "start") {
+      return Math.min((s + 1) / steps, 1);
+    }
+    return s / steps;
+  };
+}
+function spring(config = {}) {
+  const {
+    mass = 1,
+    stiffness = 100,
+    damping = 10,
+    velocity = 0
+  } = config;
+  const w0 = Math.sqrt(stiffness / mass);
+  const zeta = damping / (2 * Math.sqrt(stiffness * mass));
+  const duration = estimateSettleTime(zeta, w0);
+  return (t) => {
+    if (t <= 0) return 0;
+    if (t >= 1) return 1;
+    const time = t * duration;
+    let value;
+    if (zeta < 1) {
+      const wd = w0 * Math.sqrt(1 - zeta * zeta);
+      const A = 1;
+      const B = (zeta * w0 + velocity) / wd;
+      value = 1 - Math.exp(-zeta * w0 * time) * (A * Math.cos(wd * time) + B * Math.sin(wd * time));
+    } else if (zeta === 1) {
+      value = 1 - Math.exp(-w0 * time) * (1 + (w0 + velocity) * time);
+    } else {
+      const s1 = -w0 * (zeta - Math.sqrt(zeta * zeta - 1));
+      const s2 = -w0 * (zeta + Math.sqrt(zeta * zeta - 1));
+      const A = (velocity - s2) / (s1 - s2);
+      const B = 1 - A;
+      value = 1 - A * Math.exp(s1 * time) - B * Math.exp(s2 * time);
+    }
+    return value;
+  };
+}
+function estimateSettleTime(zeta, w0) {
+  if (zeta >= 1) {
+    return 10 / (zeta * w0);
+  }
+  return Math.log(1e3) / (zeta * w0);
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function hexToRgba(hex) {
+  let h = hex.replace("#", "");
+  if (h.length === 3)
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + "ff";
+  else if (h.length === 4)
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2] + h[3] + h[3];
+  else if (h.length === 6) h = h + "ff";
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16),
+    a: parseInt(h.slice(6, 8), 16) / 255
+  };
+}
+function rgbaToHex(color) {
+  const r = clamp(Math.round(color.r), 0, 255).toString(16).padStart(2, "0");
+  const g = clamp(Math.round(color.g), 0, 255).toString(16).padStart(2, "0");
+  const b = clamp(Math.round(color.b), 0, 255).toString(16).padStart(2, "0");
+  const a = clamp(Math.round(color.a * 255), 0, 255).toString(16).padStart(2, "0");
+  return `#${r}${g}${b}${a === "ff" ? "" : a}`;
+}
+function lerpRgba(a, b, t) {
+  return {
+    r: lerp(a.r, b.r, t),
+    g: lerp(a.g, b.g, t),
+    b: lerp(a.b, b.b, t),
+    a: lerp(a.a, b.a, t)
+  };
+}
+
+// ../core/dist/index.js
+function resolveEasing(easing) {
+  if (!easing) return linear;
+  if (typeof easing === "string") {
+    switch (easing) {
+      case "ease-in":
+        return easeIn;
+      case "ease-out":
+        return easeOut;
+      case "ease-in-out":
+        return easeInOut;
+      default:
+        return linear;
+    }
+  }
+  switch (easing.type) {
+    case "linear":
+      return linear;
+    case "cubic-bezier":
+      return cubicBezier(easing.x1, easing.y1, easing.x2, easing.y2);
+    case "spring":
+      return spring({
+        mass: easing.mass,
+        stiffness: easing.stiffness,
+        damping: easing.damping,
+        velocity: easing.velocity
+      });
+    case "step":
+      return step(easing.steps, easing.position);
+    default:
+      return linear;
+  }
+}
+function isFrameInRange(frame, range) {
+  return frame >= range[0] && frame <= range[1];
+}
+function computeProgress(frame, range) {
+  const [start, end] = range;
+  if (start === end) return 1;
+  return clamp((frame - start) / (end - start), 0, 1);
+}
+function resolveDeltaValue(delta, frame) {
+  if (!isFrameInRange(frame, delta.range)) {
+    return void 0;
+  }
+  const progress = computeProgress(frame, delta.range);
+  const easingFn = resolveEasing(delta.easing);
+  const easedProgress = easingFn(progress);
+  return interpolateValue(delta.from, delta.to, easedProgress);
+}
+function interpolateValue(from, to, t) {
+  if (typeof from === "number" && typeof to === "number") {
+    return lerp(from, to, t);
+  }
+  if (typeof from === "string" && typeof to === "string") {
+    if (from.startsWith("#") && to.startsWith("#")) {
+      return rgbaToHex(lerpRgba(hexToRgba(from), hexToRgba(to), t));
+    }
+    return t >= 1 ? to : from;
+  }
+  return t >= 1 ? to : from;
+}
+function resolvePropertyAtFrame(deltas, frame) {
+  for (const delta of deltas) {
+    if (isFrameInRange(frame, delta.range)) {
+      return resolveDeltaValue(delta, frame);
+    }
+  }
+  let lastCompleted;
+  for (const delta of deltas) {
+    if (frame > delta.range[1]) {
+      if (!lastCompleted || delta.range[1] > lastCompleted.range[1]) {
+        lastCompleted = delta;
+      }
+    }
+  }
+  return lastCompleted?.to;
+}
+function resolveFrame(doc, stateName, frame) {
+  const state = doc.states[stateName];
+  if (!state) {
+    throw new Error(`State "${stateName}" not found in document "${doc.name}"`);
+  }
+  const deltasByLayerProperty = groupDeltas(state.deltas);
+  const resolvedLayers = doc.layers.map((layer) => {
+    const computedProperties = {};
+    const layerDeltas = deltasByLayerProperty.get(layer.id);
+    if (layerDeltas) {
+      for (const [property, deltas] of layerDeltas) {
+        const value = resolvePropertyAtFrame(deltas, frame);
+        if (value !== void 0) {
+          computedProperties[property] = value;
+        }
+      }
+    }
+    return { id: layer.id, layer, computedProperties };
+  });
+  return { frame, stateName, layers: resolvedLayers };
+}
+function groupDeltas(deltas) {
+  const map = /* @__PURE__ */ new Map();
+  for (const delta of deltas) {
+    let layerMap = map.get(delta.layer);
+    if (!layerMap) {
+      layerMap = /* @__PURE__ */ new Map();
+      map.set(delta.layer, layerMap);
+    }
+    let propDeltas = layerMap.get(delta.property);
+    if (!propDeltas) {
+      propDeltas = [];
+      layerMap.set(delta.property, propDeltas);
+    }
+    propDeltas.push(delta);
+  }
+  return map;
+}
+function rangesOverlap(a, b) {
+  return a[0] <= b[1] && b[0] <= a[1];
+}
+function validateNoOverlap(existing, newDelta) {
+  for (const delta of existing) {
+    if (delta.layer === newDelta.layer && delta.property === newDelta.property && rangesOverlap(delta.range, newDelta.range)) {
+      return {
+        layerId: newDelta.layer,
+        property: newDelta.property,
+        existingRange: delta.range,
+        newRange: newDelta.range,
+        message: `Overlapping delta on layer "${newDelta.layer}" property "${newDelta.property}": existing [${delta.range[0]}-${delta.range[1]}] overlaps with new [${newDelta.range[0]}-${newDelta.range[1]}]`
+      };
+    }
+  }
+  return null;
+}
+function validateAllDeltas(deltas) {
+  const errors = [];
+  for (let i = 0; i < deltas.length; i++) {
+    for (let j = i + 1; j < deltas.length; j++) {
+      const a = deltas[i];
+      const b = deltas[j];
+      if (a.layer === b.layer && a.property === b.property && rangesOverlap(a.range, b.range)) {
+        errors.push({
+          layerId: a.layer,
+          property: a.property,
+          existingRange: a.range,
+          newRange: b.range,
+          message: `Overlapping deltas on layer "${a.layer}" property "${a.property}": [${a.range[0]}-${a.range[1]}] overlaps with [${b.range[0]}-${b.range[1]}]`
+        });
+      }
+    }
+  }
+  return errors;
+}
+function expandPreset(preset, layerId, startFrame, duration) {
+  return preset.deltas.map((pd, index) => {
+    let range;
+    if (pd.offset) {
+      range = [startFrame + pd.offset[0], startFrame + pd.offset[1]];
+    } else {
+      range = [startFrame, startFrame + duration];
+    }
+    return {
+      id: `preset-${layerId}-${index}`,
+      layer: layerId,
+      property: pd.property,
+      range,
+      from: pd.from,
+      to: pd.to,
+      easing: pd.easing
+    };
+  });
+}
+function instantiateTemplate(template, bindings) {
+  const errors = [];
+  const variables = template.variables ?? {};
+  for (const [name, variable] of Object.entries(variables)) {
+    if (bindings[name] === void 0 && variable.default === void 0) {
+      errors.push({ variable: name, message: `Required variable "${name}" not provided` });
+    }
+  }
+  for (const name of Object.keys(bindings)) {
+    if (!variables[name]) {
+      errors.push({ variable: name, message: `Unknown variable "${name}"` });
+    }
+  }
+  if (errors.length > 0) return { success: false, errors };
+  const resolved = {};
+  for (const [name, variable] of Object.entries(variables)) {
+    resolved[name] = bindings[name] ?? variable.default;
+  }
+  const doc = JSON.parse(JSON.stringify(template));
+  substituteInObject(doc, resolved);
+  delete doc.variables;
+  return { success: true, document: doc };
+}
+function substituteInObject(obj, bindings) {
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === "string") {
+      obj[key] = substituteString(value, bindings);
+    } else if (Array.isArray(value)) {
+      substituteInArray(value, bindings);
+    } else if (value !== null && typeof value === "object") {
+      substituteInObject(value, bindings);
+    }
+  }
+}
+function substituteInArray(arr, bindings) {
+  for (let i = 0; i < arr.length; i++) {
+    const value = arr[i];
+    if (typeof value === "string") {
+      arr[i] = substituteString(value, bindings);
+    } else if (Array.isArray(value)) {
+      substituteInArray(value, bindings);
+    } else if (value !== null && typeof value === "object") {
+      substituteInObject(value, bindings);
+    }
+  }
+}
+function substituteString(str, bindings) {
+  const exactMatch = str.match(/^\{\{(\w+)\}\}$/);
+  if (exactMatch) {
+    const name = exactMatch[1];
+    return name in bindings ? bindings[name] : str;
+  }
+  return str.replace(/\{\{(\w+)\}\}/g, (_, name) => {
+    return name in bindings ? String(bindings[name]) : `{{${name}}}`;
+  });
+}
+function findTemplateVariables(doc) {
+  const vars = /* @__PURE__ */ new Set();
+  scanForVariables(doc, vars);
+  return Array.from(vars);
+}
+function scanForVariables(value, vars) {
+  if (typeof value === "string") {
+    const matches = value.matchAll(/\{\{(\w+)\}\}/g);
+    for (const match of matches) {
+      vars.add(match[1]);
+    }
+  } else if (Array.isArray(value)) {
+    for (const item of value) scanForVariables(item, vars);
+  } else if (value !== null && typeof value === "object") {
+    for (const v of Object.values(value)) {
+      scanForVariables(v, vars);
+    }
+  }
+}
+
+// ../mcp/src/tools/deltas.ts
+function getDoc5(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok5(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err5(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+var AnimatablePropertyEnum = z18.enum([
+  "frame.x",
+  "frame.y",
+  "bounds.width",
+  "bounds.height",
+  "opacity",
+  "rotation",
+  "scale.x",
+  "scale.y",
+  "anchorPoint.x",
+  "anchorPoint.y",
+  "visual.shape.cornerRadius",
+  "visual.fill.color",
+  "visual.stroke.color",
+  "visual.stroke.width",
+  "visual.stroke.start",
+  "visual.stroke.end",
+  "visual.style.fontSize",
+  "visual.style.color",
+  "shadow.color",
+  "shadow.blur",
+  "shadow.offsetX",
+  "shadow.offsetY"
+]);
+var EasingInputSchema = z18.union([
+  z18.enum(["ease-in", "ease-out", "ease-in-out"]),
+  z18.object({ type: z18.literal("linear") }),
+  z18.object({
+    type: z18.literal("cubic-bezier"),
+    x1: z18.number(),
+    y1: z18.number(),
+    x2: z18.number(),
+    y2: z18.number()
+  }),
+  z18.object({
+    type: z18.literal("spring"),
+    mass: z18.number().optional(),
+    stiffness: z18.number().optional(),
+    damping: z18.number().optional(),
+    velocity: z18.number().optional()
+  }),
+  z18.object({
+    type: z18.literal("step"),
+    steps: z18.number().int().positive(),
+    position: z18.enum(["start", "end"]).optional()
+  })
+]).describe("Easing function");
+function register5(server, store) {
+  server.tool(
+    "atelier_add_delta",
+    "Add an animation delta (keyframe transition) to a state",
+    {
+      id: z18.string().describe("Document ID"),
+      stateName: z18.string().describe("State name"),
+      layer: z18.string().describe("Target layer ID"),
+      property: AnimatablePropertyEnum.describe("Property to animate"),
+      range: z18.tuple([z18.number().int().min(0), z18.number().int().min(0)]).describe("Frame range [start, end] inclusive"),
+      from: z18.unknown().describe("Starting value"),
+      to: z18.unknown().describe("Ending value"),
+      easing: EasingInputSchema.optional().describe("Easing function"),
+      description: z18.string().optional().describe("Delta description"),
+      tags: z18.array(z18.string()).optional().describe("Tags"),
+      deltaId: z18.string().optional().describe("Custom delta ID")
+    },
+    async ({ id, stateName, layer, property, range, from, to, easing, description, tags, deltaId }) => {
+      const result = getDoc5(store, id);
+      if ("error" in result) return err5(result.error);
+      const { doc } = result;
+      const state = doc.states[stateName];
+      if (!state) return err5(`State "${stateName}" not found`);
+      if (!doc.layers.some((l) => l.id === layer)) {
+        return err5(`Layer "${layer}" not found`);
+      }
+      if (range[0] > range[1]) {
+        return err5(`Invalid range: start (${range[0]}) must be <= end (${range[1]})`);
+      }
+      const delta = {
+        layer,
+        property,
+        range: [range[0], range[1]],
+        from,
+        to,
+        ...easing ? { easing } : {},
+        ...description ? { description } : {},
+        ...tags ? { tags } : {},
+        ...deltaId ? { id: deltaId } : {}
+      };
+      const overlap = validateNoOverlap(state.deltas, delta);
+      if (overlap) {
+        return err5(overlap.message);
+      }
+      state.deltas.push(delta);
+      return ok5({ stateName, deltaIndex: state.deltas.length - 1, layer, property });
+    }
+  );
+  server.tool(
+    "atelier_edit_delta",
+    "Edit an existing delta by index within a state",
+    {
+      id: z18.string().describe("Document ID"),
+      stateName: z18.string().describe("State name"),
+      deltaIndex: z18.number().int().min(0).describe("Delta index within the state"),
+      layer: z18.string().optional().describe("New target layer ID"),
+      property: AnimatablePropertyEnum.optional().describe("New property to animate"),
+      range: z18.tuple([z18.number().int().min(0), z18.number().int().min(0)]).optional().describe("New frame range [start, end]"),
+      from: z18.unknown().optional().describe("New starting value"),
+      to: z18.unknown().optional().describe("New ending value"),
+      easing: EasingInputSchema.optional().describe("New easing function"),
+      description: z18.string().optional().describe("New description"),
+      tags: z18.array(z18.string()).optional().describe("New tags")
+    },
+    async ({ id, stateName, deltaIndex, layer, property, range, from, to, easing, description, tags }) => {
+      const result = getDoc5(store, id);
+      if ("error" in result) return err5(result.error);
+      const { doc } = result;
+      const state = doc.states[stateName];
+      if (!state) return err5(`State "${stateName}" not found`);
+      if (deltaIndex >= state.deltas.length) {
+        return err5(`Delta index ${deltaIndex} out of range (${state.deltas.length} deltas)`);
+      }
+      const delta = state.deltas[deltaIndex];
+      if (layer != null) {
+        if (!doc.layers.some((l) => l.id === layer)) return err5(`Layer "${layer}" not found`);
+        delta.layer = layer;
+      }
+      if (property != null) delta.property = property;
+      if (range != null) {
+        if (range[0] > range[1]) return err5(`Invalid range: start (${range[0]}) must be <= end (${range[1]})`);
+        delta.range = [range[0], range[1]];
+      }
+      if (from !== void 0) delta.from = from;
+      if (to !== void 0) delta.to = to;
+      if (easing != null) delta.easing = easing;
+      if (description != null) delta.description = description;
+      if (tags) delta.tags = tags;
+      const others = state.deltas.filter((_, i) => i !== deltaIndex);
+      const overlap = validateNoOverlap(others, delta);
+      if (overlap) {
+        return err5(`Edit would cause overlap: ${overlap.message}`);
+      }
+      return ok5({ stateName, deltaIndex, updated: true });
+    }
+  );
+  server.tool(
+    "atelier_remove_delta",
+    "Remove a delta by index from a state",
+    {
+      id: z18.string().describe("Document ID"),
+      stateName: z18.string().describe("State name"),
+      deltaIndex: z18.number().int().min(0).describe("Delta index to remove")
+    },
+    async ({ id, stateName, deltaIndex }) => {
+      const result = getDoc5(store, id);
+      if ("error" in result) return err5(result.error);
+      const { doc } = result;
+      const state = doc.states[stateName];
+      if (!state) return err5(`State "${stateName}" not found`);
+      if (deltaIndex >= state.deltas.length) {
+        return err5(`Delta index ${deltaIndex} out of range (${state.deltas.length} deltas)`);
+      }
+      const removed = state.deltas.splice(deltaIndex, 1)[0];
+      return ok5({
+        stateName,
+        removed: {
+          layer: removed.layer,
+          property: removed.property,
+          range: removed.range
+        },
+        remainingDeltas: state.deltas.length
+      });
+    }
+  );
+  server.tool(
+    "atelier_apply_preset",
+    "Apply a preset to a layer, expanding it into concrete deltas",
+    {
+      id: z18.string().describe("Document ID"),
+      stateName: z18.string().describe("State name to add deltas to"),
+      presetName: z18.string().describe("Preset name defined in the document"),
+      layerId: z18.string().describe("Target layer ID"),
+      startFrame: z18.number().int().min(0).optional().describe("Start frame (default: 0)"),
+      duration: z18.number().positive().int().optional().describe("Duration for preset (default: state duration)")
+    },
+    async ({ id, stateName, presetName, layerId, startFrame, duration }) => {
+      const result = getDoc5(store, id);
+      if ("error" in result) return err5(result.error);
+      const { doc } = result;
+      const state = doc.states[stateName];
+      if (!state) return err5(`State "${stateName}" not found`);
+      if (!doc.layers.some((l) => l.id === layerId)) {
+        return err5(`Layer "${layerId}" not found`);
+      }
+      if (!doc.presets || !doc.presets[presetName]) {
+        return err5(`Preset "${presetName}" not found`);
+      }
+      const preset = doc.presets[presetName];
+      const start = startFrame ?? 0;
+      const dur = duration ?? state.duration;
+      const deltas = expandPreset(preset, layerId, start, dur);
+      const errors = [];
+      for (const delta of deltas) {
+        const overlap = validateNoOverlap(state.deltas, delta);
+        if (overlap) {
+          errors.push(overlap.message);
+        }
+      }
+      if (errors.length > 0) {
+        return err5(`Preset would cause overlaps:
+${errors.join("\n")}`);
+      }
+      state.deltas.push(...deltas);
+      return ok5({
+        stateName,
+        presetName,
+        layerId,
+        deltasAdded: deltas.length,
+        totalDeltas: state.deltas.length
+      });
+    }
+  );
+}
+
+// ../mcp/src/tools/presets.ts
+import { z as z19 } from "zod";
+function getDoc6(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok6(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err6(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+var AnimatablePropertyEnum2 = z19.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.style.fontSize",
+  "visual.style.color"
+]);
+var EasingInputSchema2 = z19.union([
+  z19.enum(["ease-in", "ease-out", "ease-in-out"]),
+  z19.object({ type: z19.literal("linear") }),
+  z19.object({
+    type: z19.literal("cubic-bezier"),
+    x1: z19.number(),
+    y1: z19.number(),
+    x2: z19.number(),
+    y2: z19.number()
+  }),
+  z19.object({
+    type: z19.literal("spring"),
+    mass: z19.number().optional(),
+    stiffness: z19.number().optional(),
+    damping: z19.number().optional(),
+    velocity: z19.number().optional()
+  }),
+  z19.object({
+    type: z19.literal("step"),
+    steps: z19.number().int().positive(),
+    position: z19.enum(["start", "end"]).optional()
+  })
+]);
+var PresetDeltaSchema2 = z19.object({
+  property: AnimatablePropertyEnum2.describe("Animatable property"),
+  offset: z19.tuple([z19.number().int().min(0), z19.number().int().min(0)]).optional().describe("Relative frame offset [start, end]"),
+  from: z19.unknown().describe("Starting value"),
+  to: z19.unknown().describe("Ending value"),
+  easing: EasingInputSchema2.optional().describe("Easing function")
+});
+function register6(server, store) {
+  server.tool(
+    "atelier_define_preset",
+    "Define a reusable animation preset on a document",
+    {
+      id: z19.string().describe("Document ID"),
+      presetName: z19.string().describe("Preset name"),
+      description: z19.string().optional().describe("Preset description"),
+      tags: z19.array(z19.string()).optional().describe("Tags"),
+      deltas: z19.array(PresetDeltaSchema2).min(1).describe("Array of preset delta definitions")
+    },
+    async ({ id, presetName, description, tags, deltas }) => {
+      const result = getDoc6(store, id);
+      if ("error" in result) return err6(result.error);
+      const { doc } = result;
+      if (!doc.presets) doc.presets = {};
+      const preset = {
+        deltas,
+        ...description ? { description } : {},
+        ...tags ? { tags } : {}
+      };
+      doc.presets[presetName] = preset;
+      return ok6({ presetName, deltaCount: deltas.length });
+    }
+  );
+  server.tool(
+    "atelier_list_presets",
+    "List all presets defined on a document",
+    {
+      id: z19.string().describe("Document ID")
+    },
+    async ({ id }) => {
+      const result = getDoc6(store, id);
+      if ("error" in result) return err6(result.error);
+      const { doc } = result;
+      if (!doc.presets || Object.keys(doc.presets).length === 0) {
+        return ok6({ presets: [], count: 0 });
+      }
+      const presets = Object.entries(doc.presets).map(([name, preset]) => ({
+        name,
+        description: preset.description,
+        tags: preset.tags,
+        deltaCount: preset.deltas.length,
+        properties: preset.deltas.map((d) => d.property)
+      }));
+      return ok6({ presets, count: presets.length });
+    }
+  );
+}
+
+// ../mcp/src/tools/preview.ts
+import { z as z20 } from "zod";
+function getDoc7(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok7(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err7(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+function register7(server, store) {
+  server.tool(
+    "atelier_validate",
+    "Validate an Atelier document for schema correctness and delta overlaps",
+    {
+      id: z20.string().describe("Document ID")
+    },
+    async ({ id }) => {
+      const result = getDoc7(store, id);
+      if ("error" in result) return err7(result.error);
+      const { doc } = result;
+      const schemaResult = validateDocument(doc);
+      const schemaErrors = schemaResult.success ? [] : schemaResult.errors;
+      const overlapErrors = [];
+      for (const [stateName, state] of Object.entries(doc.states)) {
+        const overlaps = validateAllDeltas(state.deltas);
+        for (const overlap of overlaps) {
+          overlapErrors.push({ state: stateName, message: overlap.message });
+        }
+      }
+      const valid = schemaErrors.length === 0 && overlapErrors.length === 0;
+      return ok7({
+        valid,
+        schemaErrors,
+        overlapErrors,
+        summary: valid ? "Document is valid" : `Found ${schemaErrors.length} schema error(s) and ${overlapErrors.length} overlap error(s)`
+      });
+    }
+  );
+  server.tool(
+    "atelier_preview",
+    "Preview the resolved state of all layers at a specific frame",
+    {
+      id: z20.string().describe("Document ID"),
+      stateName: z20.string().describe("State name to preview"),
+      frame: z20.number().int().min(0).describe("Frame number to resolve")
+    },
+    async ({ id, stateName, frame }) => {
+      const result = getDoc7(store, id);
+      if ("error" in result) return err7(result.error);
+      const { doc } = result;
+      if (!doc.states[stateName]) {
+        return err7(`State "${stateName}" not found`);
+      }
+      try {
+        const resolved = resolveFrame(doc, stateName, frame);
+        const layers = resolved.layers.map((rl) => ({
+          id: rl.id,
+          visualType: rl.layer.visual.type,
+          baseFrame: rl.layer.frame,
+          baseBounds: rl.layer.bounds,
+          baseOpacity: rl.layer.opacity,
+          baseRotation: rl.layer.rotation,
+          computedProperties: rl.computedProperties
+        }));
+        return ok7({
+          stateName: resolved.stateName,
+          frame: resolved.frame,
+          duration: doc.states[stateName].duration,
+          layers
+        });
+      } catch (e) {
+        return err7(`Preview failed: ${e.message}`);
+      }
+    }
+  );
+}
+
+// ../mcp/src/tools/templates.ts
+import { z as z21 } from "zod";
+function getDoc8(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok8(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err8(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+function register8(server, store) {
+  server.tool(
+    "atelier_instantiate_template",
+    "Instantiate a template document with variable bindings. Creates a new document in the store.",
+    {
+      id: z21.string().describe("Template document ID"),
+      bindings: z21.record(z21.unknown()).describe("Variable bindings: { variableName: value }")
+    },
+    async ({ id, bindings }) => {
+      const result = getDoc8(store, id);
+      if ("error" in result) return err8(result.error);
+      const { doc } = result;
+      const templateResult = instantiateTemplate(doc, bindings);
+      if (!templateResult.success) {
+        return err8(`Template errors: ${templateResult.errors.map((e) => `${e.variable}: ${e.message}`).join("; ")}`);
+      }
+      const newId = store.create(templateResult.document);
+      return ok8({
+        id: newId,
+        name: templateResult.document.name,
+        message: "Template instantiated successfully"
+      });
+    }
+  );
+  server.tool(
+    "atelier_find_variables",
+    "Scan a document for {{variableName}} patterns. Returns the list of variable references found.",
+    {
+      id: z21.string().describe("Document ID")
+    },
+    async ({ id }) => {
+      const result = getDoc8(store, id);
+      if ("error" in result) return err8(result.error);
+      const { doc } = result;
+      const variables = findTemplateVariables(doc);
+      const declared = doc.variables ? Object.keys(doc.variables) : [];
+      return ok8({
+        variables,
+        declared,
+        undeclared: variables.filter((v) => !declared.includes(v)),
+        unused: declared.filter((d) => !variables.includes(d))
+      });
+    }
+  );
+}
+
+// ../mcp/src/index.ts
+function createServer() {
+  const store = new DocumentStore();
+  const server = new McpServer(
+    { name: "atelier", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  register(server, store);
+  register2(server, store);
+  register3(server, store);
+  register4(server, store);
+  register5(server, store);
+  register6(server, store);
+  register7(server, store);
+  register8(server, store);
+  return { server, store };
+}
+var isMain = typeof process !== "undefined" && process.argv[1] && (process.argv[1].endsWith("/index.js") || process.argv[1].endsWith("/index.cjs") || process.argv[1].includes("atelier-mcp"));
+if (isMain) {
+  const { server } = createServer();
+  const transport = new StdioServerTransport();
+  server.connect(transport).catch((error) => {
+    console.error("Failed to start Atelier MCP server:", error);
+    process.exit(1);
+  });
+}
+export {
+  DocumentStore,
+  createServer,
+  register5 as registerDeltaTools,
+  register as registerDocumentTools,
+  register2 as registerLayerTools,
+  register6 as registerPresetTools,
+  register7 as registerPreviewTools,
+  register3 as registerShapeTools,
+  register4 as registerStateTools,
+  register8 as registerTemplateTools
+};
+//# sourceMappingURL=mcp.js.map