@a-company/atelier 0.28.2 → 0.36.0

package/dist/mcp.cjs

@@ -21,18 +21,24 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // ../mcp/src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BRIDGE_PROTOCOL_VERSION: () => BRIDGE_PROTOCOL_VERSION,
   DocumentStore: () => DocumentStore,
+  WebSocketServerTransport: () => WebSocketServerTransport,
   createServer: () => createServer,
+  isBridgeEnvelope: () => isBridgeEnvelope,
   registerAssetTools: () => register12,
   registerDeltaTools: () => register5,
   registerDocumentTools: () => register,
   registerExportTools: () => register11,
+  registerImportImageTools: () => register19,
   registerInteractionTools: () => register14,
   registerLayerEffectTools: () => register9,
   registerLayerTools: () => register2,
+  registerOverlayTools: () => register17,
   registerPerformanceTools: () => register16,
   registerPresetTools: () => register6,
   registerPreviewTools: () => register7,
+  registerRecipeTools: () => register18,
   registerRefTools: () => register15,
   registerShapeTools: () => register3,
   registerStateConfigTools: () => register10,
@@ -52,13 +58,15 @@ function generateId() {
 }
 var DocumentStore = class {
   docs = /* @__PURE__ */ new Map();
+  listeners = [];
   /** Create a new document entry. Returns the assigned ID. */
-  create(doc, id) {
+  create(doc, id, source = "system") {
     const docId = id ?? generateId();
     if (this.docs.has(docId)) {
       throw new Error(`Document "${docId}" already exists`);
     }
     this.docs.set(docId, doc);
+    this.emit(docId, doc, source);
     return docId;
   }
   /** Get a document by ID. */
@@ -66,12 +74,15 @@ var DocumentStore = class {
     return this.docs.get(id);
   }
   /** Set (overwrite) a document by ID. */
-  set(id, doc) {
+  set(id, doc, source = "system") {
     this.docs.set(id, doc);
+    this.emit(id, doc, source);
   }
   /** Delete a document by ID. Returns true if it existed. */
-  delete(id) {
-    return this.docs.delete(id);
+  delete(id, source = "system") {
+    const existed = this.docs.delete(id);
+    if (existed) this.emit(id, null, source);
+    return existed;
   }
   /** Check if a document exists. */
   has(id) {
@@ -85,14 +96,43 @@ var DocumentStore = class {
     }
     return result;
   }
-  /** Clear all documents (useful for testing). */
+  /** Clear all documents (useful for testing). Does NOT fire onChange. */
   clear() {
     this.docs.clear();
   }
+  /**
+   * Subscribe to mutation events. The listener is invoked after every
+   * create()/set()/delete() with the changed document ID, the new value
+   * (or `null` when deleted), and the source tag.
+   *
+   * Returns an unsubscribe function. Multiple listeners are supported and
+   * delivered in registration order. A listener that throws is isolated —
+   * the error is swallowed and remaining listeners still fire.
+   *
+   * TODO(#10): the live WS bridge will subscribe here to forward LLM-side
+   * mutations into the in-browser Studio (which exposes the symmetric
+   * `AtelierStudio.applyMutation()` API).
+   */
+  onChange(listener) {
+    this.listeners.push(listener);
+    return () => {
+      const idx = this.listeners.indexOf(listener);
+      if (idx !== -1) this.listeners.splice(idx, 1);
+    };
+  }
+  emit(id, doc, source) {
+    const snapshot = this.listeners.slice();
+    for (const listener of snapshot) {
+      try {
+        listener(id, doc, source);
+      } catch {
+      }
+    }
+  }
 };
 
 // ../mcp/src/tools/document.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 
 // ../schema/dist/index.js
 var import_zod = require("zod");
@@ -109,6 +149,7 @@ var import_zod11 = require("zod");
 var import_zod12 = require("zod");
 var import_zod13 = require("zod");
 var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var import_yaml = require("yaml");
 var PixelSchema = import_zod.z.number();
 var PercentageSchema = import_zod.z.string().regex(/^-?\d+(\.\d+)?%$/, {
@@ -350,6 +391,18 @@ var ImageVisualSchema = import_zod7.z.object({
   spritesheet: SpritesheetConfigSchema.optional(),
   frameIndex: import_zod7.z.number().int().min(0).optional()
 });
+var VideoVisualSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("video"),
+  assetId: import_zod7.z.string().min(1, "assetId is required"),
+  src: import_zod7.z.string().optional(),
+  startFrame: import_zod7.z.number().int().min(0).optional(),
+  sourceOffset: import_zod7.z.number().min(0).optional(),
+  sourceEnd: import_zod7.z.number().positive().optional(),
+  playbackRate: import_zod7.z.number().positive().optional(),
+  volume: import_zod7.z.number().min(0).max(1).optional(),
+  muted: import_zod7.z.boolean().optional(),
+  objectFit: import_zod7.z.enum(["contain", "cover", "fill"]).optional()
+});
 var GroupVisualSchema = import_zod7.z.object({
   type: import_zod7.z.literal("group")
 });
@@ -363,6 +416,7 @@ var VisualSchema = import_zod7.z.discriminatedUnion("type", [
   ShapeVisualSchema,
   TextVisualSchema,
   ImageVisualSchema,
+  VideoVisualSchema,
   GroupVisualSchema,
   RefVisualSchema
 ]);
@@ -482,7 +536,7 @@ var VariableSchema = import_zod12.z.object({
   default: import_zod12.z.unknown().optional(),
   description: import_zod12.z.string().optional()
 });
-var AssetTypeSchema = import_zod13.z.enum(["image", "svg", "font", "animation", "audio"]);
+var AssetTypeSchema = import_zod13.z.enum(["image", "svg", "font", "animation", "audio", "video"]);
 var AssetSchema = import_zod13.z.object({
   type: AssetTypeSchema,
   src: import_zod13.z.string().min(1, "Asset src is required"),
@@ -493,6 +547,12 @@ var AssetSchema = import_zod13.z.object({
     frameCount: import_zod13.z.number().int().positive().optional(),
     frameWidth: import_zod13.z.number().positive(),
     frameHeight: import_zod13.z.number().positive()
+  }).optional(),
+  videoMeta: import_zod13.z.object({
+    duration: import_zod13.z.number().positive("videoMeta.duration must be positive"),
+    fps: import_zod13.z.number().positive("videoMeta.fps must be positive"),
+    width: import_zod13.z.number().int().positive(),
+    height: import_zod13.z.number().int().positive()
   }).optional()
 });
 var CanvasSchema = import_zod14.z.object({
@@ -513,6 +573,121 @@ var AtelierDocumentSchema = import_zod14.z.object({
   layers: import_zod14.z.array(LayerSchema),
   states: import_zod14.z.record(import_zod14.z.string(), StateSchema)
 });
+var SilencePolicySchema = import_zod15.z.object({
+  noise: import_zod15.z.string().optional(),
+  min_silence: import_zod15.z.number().nonnegative().optional(),
+  default_padding_pre: import_zod15.z.number().nonnegative().optional(),
+  default_padding_post: import_zod15.z.number().nonnegative().optional(),
+  match_tolerance: import_zod15.z.number().nonnegative().optional()
+}).strict();
+var CaptionStyleSchema = import_zod15.z.object({
+  font_family: import_zod15.z.string().optional(),
+  font_size: import_zod15.z.number().positive().optional(),
+  font_weight: import_zod15.z.union([import_zod15.z.literal("normal"), import_zod15.z.literal("bold"), import_zod15.z.number()]).optional(),
+  text_align: import_zod15.z.enum(["left", "center", "right"]).optional(),
+  color: import_zod15.z.string().optional(),
+  y_ratio: import_zod15.z.number().min(0).max(1).optional(),
+  width_ratio: import_zod15.z.number().min(0).max(1).optional(),
+  fade_seconds: import_zod15.z.number().nonnegative().optional()
+}).strict();
+var CaptionGroupingSchema = import_zod15.z.object({
+  max_words: import_zod15.z.number().int().positive().optional(),
+  pause_gap: import_zod15.z.number().nonnegative().optional()
+}).strict();
+var OverlayAnchorSchema = import_zod15.z.enum([
+  "top-left",
+  "top-right",
+  "bottom-left",
+  "bottom-right"
+]);
+var OverlayTextStyleSchema = import_zod15.z.object({
+  font_family: import_zod15.z.string().optional(),
+  font_size: import_zod15.z.number().positive().optional(),
+  font_weight: import_zod15.z.union([import_zod15.z.literal("normal"), import_zod15.z.literal("bold"), import_zod15.z.number()]).optional(),
+  color: import_zod15.z.string().optional()
+}).strict();
+function validatePageNumberFormat(format, ctx) {
+  if (format.length === 0) {
+    ctx.addIssue({
+      code: import_zod15.z.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: import_zod15.z.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: import_zod15.z.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: import_zod15.z.ZodIssueCode.custom,
+      message: "format must contain at least one {current} or {total} placeholder"
+    });
+  }
+}
+var OverlayHandleRuleSchema = import_zod15.z.object({
+  text: import_zod15.z.string().min(1),
+  anchor: OverlayAnchorSchema,
+  margin: import_zod15.z.number().nonnegative().optional(),
+  style: OverlayTextStyleSchema.optional()
+}).strict();
+var OverlayPageNumberRuleSchema = import_zod15.z.object({
+  format: import_zod15.z.string().superRefine(validatePageNumberFormat),
+  anchor: OverlayAnchorSchema,
+  margin: import_zod15.z.number().nonnegative().optional(),
+  style: OverlayTextStyleSchema.optional()
+}).strict();
+var OverlayRulesSchema = import_zod15.z.object({
+  handle: OverlayHandleRuleSchema.optional(),
+  page_number: OverlayPageNumberRuleSchema.optional()
+}).strict();
+var StudioRecipeSchema = import_zod15.z.object({
+  version: import_zod15.z.string(),
+  name: import_zod15.z.string(),
+  description: import_zod15.z.string().optional(),
+  author: import_zod15.z.string().optional(),
+  tags: import_zod15.z.array(import_zod15.z.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: import_zod15.z.unknown().optional(),
+  transition_kit: import_zod15.z.unknown().optional(),
+  palette: import_zod15.z.unknown().optional(),
+  audio_policy: import_zod15.z.unknown().optional(),
+  aspect_targets: import_zod15.z.array(import_zod15.z.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)",
@@ -526,14 +701,30 @@ function validateDocument(input) {
   }
   return { success: false, errors: formatErrors(result.error) };
 }
+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 = (0, import_yaml.parse)(yamlString);
-  } catch (err17) {
+  } catch (err20) {
     return {
       success: false,
-      errors: [{ path: "(yaml)", message: `YAML parse error: ${err17.message}` }]
+      errors: [{ path: "(yaml)", message: `YAML parse error: ${err20.message}` }]
     };
   }
   return validateDocument(parsed);
@@ -559,13 +750,13 @@ function register(server, store) {
     "atelier_create",
     "Create a new Atelier animation document with canvas settings",
     {
-      name: import_zod15.z.string().describe("Animation name"),
-      width: import_zod15.z.number().positive().describe("Canvas width in pixels"),
-      height: import_zod15.z.number().positive().describe("Canvas height in pixels"),
-      fps: import_zod15.z.number().positive().int().describe("Frames per second"),
-      background: import_zod15.z.string().optional().describe("Background color (hex string)"),
-      description: import_zod15.z.string().optional().describe("Animation description"),
-      tags: import_zod15.z.array(import_zod15.z.string()).optional().describe("Tags for categorization")
+      name: import_zod16.z.string().describe("Animation name"),
+      width: import_zod16.z.number().positive().describe("Canvas width in pixels"),
+      height: import_zod16.z.number().positive().describe("Canvas height in pixels"),
+      fps: import_zod16.z.number().positive().int().describe("Frames per second"),
+      background: import_zod16.z.string().optional().describe("Background color (hex string)"),
+      description: import_zod16.z.string().optional().describe("Animation description"),
+      tags: import_zod16.z.array(import_zod16.z.string()).optional().describe("Tags for categorization")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ name, width, height, fps, background, description, tags }) => {
@@ -590,7 +781,7 @@ function register(server, store) {
     "atelier_info",
     "Get summary information about an Atelier document",
     {
-      id: import_zod15.z.string().describe("Document ID")
+      id: import_zod16.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -618,8 +809,8 @@ function register(server, store) {
     "atelier_load",
     "Load an Atelier document from a YAML string",
     {
-      id: import_zod15.z.string().optional().describe("Custom document ID (auto-generated if omitted)"),
-      yaml: import_zod15.z.string().describe("YAML string representing an Atelier document")
+      id: import_zod16.z.string().optional().describe("Custom document ID (auto-generated if omitted)"),
+      yaml: import_zod16.z.string().describe("YAML string representing an Atelier document")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, yaml }) => {
@@ -635,7 +826,7 @@ function register(server, store) {
     "atelier_export",
     "Export an Atelier document as a YAML string",
     {
-      id: import_zod15.z.string().describe("Document ID")
+      id: import_zod16.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -658,7 +849,7 @@ function register(server, store) {
 }
 
 // ../mcp/src/tools/layers.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 function getDoc2(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -670,69 +861,69 @@ function ok2(data) {
 function err2(message) {
   return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
 }
-var VisualInputSchema = import_zod16.z.object({
-  type: import_zod16.z.enum(["shape", "text", "image", "group", "ref"]).describe("Visual type"),
+var VisualInputSchema = import_zod17.z.object({
+  type: import_zod17.z.enum(["shape", "text", "image", "group", "ref"]).describe("Visual type"),
   // shape visual fields
-  shape: import_zod16.z.object({
-    type: import_zod16.z.enum(["rect", "ellipse", "path"]),
-    cornerRadius: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.tuple([import_zod16.z.number(), import_zod16.z.number(), import_zod16.z.number(), import_zod16.z.number()])]).optional(),
-    points: import_zod16.z.array(import_zod16.z.object({
-      x: import_zod16.z.number(),
-      y: import_zod16.z.number(),
-      in: import_zod16.z.object({ x: import_zod16.z.number(), y: import_zod16.z.number() }).optional(),
-      out: import_zod16.z.object({ x: import_zod16.z.number(), y: import_zod16.z.number() }).optional()
+  shape: import_zod17.z.object({
+    type: import_zod17.z.enum(["rect", "ellipse", "path"]),
+    cornerRadius: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.tuple([import_zod17.z.number(), import_zod17.z.number(), import_zod17.z.number(), import_zod17.z.number()])]).optional(),
+    points: import_zod17.z.array(import_zod17.z.object({
+      x: import_zod17.z.number(),
+      y: import_zod17.z.number(),
+      in: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional(),
+      out: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional()
     })).optional(),
-    closed: import_zod16.z.boolean().optional()
+    closed: import_zod17.z.boolean().optional()
   }).optional(),
-  fill: import_zod16.z.record(import_zod16.z.unknown()).optional(),
-  stroke: import_zod16.z.record(import_zod16.z.unknown()).optional(),
+  fill: import_zod17.z.record(import_zod17.z.unknown()).optional(),
+  stroke: import_zod17.z.record(import_zod17.z.unknown()).optional(),
   // text visual fields
-  content: import_zod16.z.string().optional(),
-  style: import_zod16.z.record(import_zod16.z.unknown()).optional(),
+  content: import_zod17.z.string().optional(),
+  style: import_zod17.z.record(import_zod17.z.unknown()).optional(),
   // image visual fields
-  assetId: import_zod16.z.string().optional(),
-  sourceRect: import_zod16.z.object({
-    x: import_zod16.z.number(),
-    y: import_zod16.z.number(),
-    width: import_zod16.z.number().positive(),
-    height: import_zod16.z.number().positive()
+  assetId: import_zod17.z.string().optional(),
+  sourceRect: import_zod17.z.object({
+    x: import_zod17.z.number(),
+    y: import_zod17.z.number(),
+    width: import_zod17.z.number().positive(),
+    height: import_zod17.z.number().positive()
   }).optional(),
-  spritesheet: import_zod16.z.object({
-    columns: import_zod16.z.number().int().positive(),
-    rows: import_zod16.z.number().int().positive(),
-    frameCount: import_zod16.z.number().int().positive().optional(),
-    frameWidth: import_zod16.z.number().positive(),
-    frameHeight: import_zod16.z.number().positive()
+  spritesheet: import_zod17.z.object({
+    columns: import_zod17.z.number().int().positive(),
+    rows: import_zod17.z.number().int().positive(),
+    frameCount: import_zod17.z.number().int().positive().optional(),
+    frameWidth: import_zod17.z.number().positive(),
+    frameHeight: import_zod17.z.number().positive()
   }).optional(),
-  frameIndex: import_zod16.z.number().int().min(0).optional(),
+  frameIndex: import_zod17.z.number().int().min(0).optional(),
   // ref visual fields
-  src: import_zod16.z.string().optional(),
-  state: import_zod16.z.string().optional(),
-  frame: import_zod16.z.number().int().min(0).optional()
+  src: import_zod17.z.string().optional(),
+  state: import_zod17.z.string().optional(),
+  frame: import_zod17.z.number().int().min(0).optional()
 }).describe("Visual content definition");
 function register2(server, store) {
   server.tool(
     "atelier_add_layer",
     "Add a new layer to an Atelier document",
     {
-      id: import_zod16.z.string().describe("Document ID"),
-      layerId: import_zod16.z.string().describe("Unique layer ID"),
+      id: import_zod17.z.string().describe("Document ID"),
+      layerId: import_zod17.z.string().describe("Unique layer ID"),
       visual: VisualInputSchema.describe("Visual content definition"),
-      x: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).describe("X position (pixels or percentage)"),
-      y: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).describe("Y position (pixels or percentage)"),
-      width: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).describe("Width (pixels or percentage)"),
-      height: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).describe("Height (pixels or percentage)"),
-      description: import_zod16.z.string().optional().describe("Layer description"),
-      tags: import_zod16.z.array(import_zod16.z.string()).optional().describe("Tags"),
-      opacity: import_zod16.z.number().min(0).max(1).optional().describe("Opacity 0-1"),
-      rotation: import_zod16.z.number().optional().describe("Rotation in degrees"),
-      parentId: import_zod16.z.string().optional().describe("Parent layer ID for transform inheritance"),
-      anchorPoint: import_zod16.z.object({ x: import_zod16.z.number(), y: import_zod16.z.number() }).optional().describe("Anchor point (0-1 normalized)"),
-      scale: import_zod16.z.object({ x: import_zod16.z.number(), y: import_zod16.z.number() }).optional().describe("Scale factors"),
-      visible: import_zod16.z.boolean().optional().describe("Whether layer is visible"),
-      tint: import_zod16.z.object({
-        color: import_zod16.z.string().describe("Tint color (hex string)"),
-        amount: import_zod16.z.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
+      x: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).describe("X position (pixels or percentage)"),
+      y: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).describe("Y position (pixels or percentage)"),
+      width: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).describe("Width (pixels or percentage)"),
+      height: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).describe("Height (pixels or percentage)"),
+      description: import_zod17.z.string().optional().describe("Layer description"),
+      tags: import_zod17.z.array(import_zod17.z.string()).optional().describe("Tags"),
+      opacity: import_zod17.z.number().min(0).max(1).optional().describe("Opacity 0-1"),
+      rotation: import_zod17.z.number().optional().describe("Rotation in degrees"),
+      parentId: import_zod17.z.string().optional().describe("Parent layer ID for transform inheritance"),
+      anchorPoint: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional().describe("Anchor point (0-1 normalized)"),
+      scale: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional().describe("Scale factors"),
+      visible: import_zod17.z.boolean().optional().describe("Whether layer is visible"),
+      tint: import_zod17.z.object({
+        color: import_zod17.z.string().describe("Tint color (hex string)"),
+        amount: import_zod17.z.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
       }).optional().describe("Color tint overlay")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -769,20 +960,20 @@ function register2(server, store) {
     "atelier_edit_layer",
     "Edit properties of an existing layer",
     {
-      id: import_zod16.z.string().describe("Document ID"),
-      layerId: import_zod16.z.string().describe("Layer ID to edit"),
-      x: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).optional().describe("New X position"),
-      y: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).optional().describe("New Y position"),
-      width: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).optional().describe("New width"),
-      height: import_zod16.z.union([import_zod16.z.number(), import_zod16.z.string()]).optional().describe("New height"),
-      description: import_zod16.z.string().optional().describe("New description"),
-      tags: import_zod16.z.array(import_zod16.z.string()).optional().describe("New tags"),
-      opacity: import_zod16.z.number().min(0).max(1).optional().describe("New opacity"),
-      rotation: import_zod16.z.number().optional().describe("New rotation"),
-      parentId: import_zod16.z.string().nullable().optional().describe("New parent layer ID (null to clear)"),
-      anchorPoint: import_zod16.z.object({ x: import_zod16.z.number(), y: import_zod16.z.number() }).optional().describe("New anchor point"),
-      scale: import_zod16.z.object({ x: import_zod16.z.number(), y: import_zod16.z.number() }).optional().describe("New scale"),
-      visible: import_zod16.z.boolean().optional().describe("New visibility")
+      id: import_zod17.z.string().describe("Document ID"),
+      layerId: import_zod17.z.string().describe("Layer ID to edit"),
+      x: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).optional().describe("New X position"),
+      y: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).optional().describe("New Y position"),
+      width: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).optional().describe("New width"),
+      height: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).optional().describe("New height"),
+      description: import_zod17.z.string().optional().describe("New description"),
+      tags: import_zod17.z.array(import_zod17.z.string()).optional().describe("New tags"),
+      opacity: import_zod17.z.number().min(0).max(1).optional().describe("New opacity"),
+      rotation: import_zod17.z.number().optional().describe("New rotation"),
+      parentId: import_zod17.z.string().nullable().optional().describe("New parent layer ID (null to clear)"),
+      anchorPoint: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional().describe("New anchor point"),
+      scale: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional().describe("New scale"),
+      visible: import_zod17.z.boolean().optional().describe("New visibility")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, x, y, width, height, description, tags, opacity, rotation, parentId, anchorPoint, scale, visible }) => {
@@ -817,8 +1008,8 @@ function register2(server, store) {
     "atelier_remove_layer",
     "Remove a layer from an Atelier document",
     {
-      id: import_zod16.z.string().describe("Document ID"),
-      layerId: import_zod16.z.string().describe("Layer ID to remove")
+      id: import_zod17.z.string().describe("Document ID"),
+      layerId: import_zod17.z.string().describe("Layer ID to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, layerId }) => {
@@ -846,7 +1037,7 @@ function register2(server, store) {
     "atelier_list_layers",
     "List all layers in an Atelier document",
     {
-      id: import_zod16.z.string().describe("Document ID")
+      id: import_zod17.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -873,9 +1064,9 @@ function register2(server, store) {
     "atelier_reorder",
     "Move a layer to a new position in the layer stack",
     {
-      id: import_zod16.z.string().describe("Document ID"),
-      layerId: import_zod16.z.string().describe("Layer ID to move"),
-      position: import_zod16.z.number().int().min(0).describe("Target position index (0-based)")
+      id: import_zod17.z.string().describe("Document ID"),
+      layerId: import_zod17.z.string().describe("Layer ID to move"),
+      position: import_zod17.z.number().int().min(0).describe("Target position index (0-based)")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, position }) => {
@@ -893,7 +1084,7 @@ function register2(server, store) {
 }
 
 // ../mcp/src/tools/shapes.ts
-var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 function getDoc3(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -910,21 +1101,21 @@ function register3(server, store) {
     "atelier_set_shape",
     "Set the shape on a shape-type layer",
     {
-      id: import_zod17.z.string().describe("Document ID"),
-      layerId: import_zod17.z.string().describe("Layer ID (must be a shape visual)"),
-      shape: import_zod17.z.object({
-        type: import_zod17.z.enum(["rect", "ellipse", "path"]).describe("Shape type"),
-        cornerRadius: import_zod17.z.union([
-          import_zod17.z.number(),
-          import_zod17.z.tuple([import_zod17.z.number(), import_zod17.z.number(), import_zod17.z.number(), import_zod17.z.number()])
+      id: import_zod18.z.string().describe("Document ID"),
+      layerId: import_zod18.z.string().describe("Layer ID (must be a shape visual)"),
+      shape: import_zod18.z.object({
+        type: import_zod18.z.enum(["rect", "ellipse", "path"]).describe("Shape type"),
+        cornerRadius: import_zod18.z.union([
+          import_zod18.z.number(),
+          import_zod18.z.tuple([import_zod18.z.number(), import_zod18.z.number(), import_zod18.z.number(), import_zod18.z.number()])
         ]).optional().describe("Corner radius (rect only)"),
-        points: import_zod17.z.array(import_zod17.z.object({
-          x: import_zod17.z.number(),
-          y: import_zod17.z.number(),
-          in: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional(),
-          out: import_zod17.z.object({ x: import_zod17.z.number(), y: import_zod17.z.number() }).optional()
+        points: import_zod18.z.array(import_zod18.z.object({
+          x: import_zod18.z.number(),
+          y: import_zod18.z.number(),
+          in: import_zod18.z.object({ x: import_zod18.z.number(), y: import_zod18.z.number() }).optional(),
+          out: import_zod18.z.object({ x: import_zod18.z.number(), y: import_zod18.z.number() }).optional()
         })).optional().describe("Path points (path only)"),
-        closed: import_zod17.z.boolean().optional().describe("Whether path is closed (path only)")
+        closed: import_zod18.z.boolean().optional().describe("Whether path is closed (path only)")
       }).describe("Shape definition")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -943,20 +1134,20 @@ function register3(server, store) {
     "atelier_set_fill",
     "Set the fill on a shape-type layer",
     {
-      id: import_zod17.z.string().describe("Document ID"),
-      layerId: import_zod17.z.string().describe("Layer ID (must be a shape visual)"),
-      fill: import_zod17.z.object({
-        type: import_zod17.z.enum(["solid", "linear-gradient", "radial-gradient"]).describe("Fill type"),
-        color: import_zod17.z.unknown().optional().describe("Color for solid fill (hex string or RGBA/HSLA object)"),
-        angle: import_zod17.z.number().optional().describe("Angle in degrees (linear-gradient only)"),
-        center: import_zod17.z.object({
-          x: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]),
-          y: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()])
+      id: import_zod18.z.string().describe("Document ID"),
+      layerId: import_zod18.z.string().describe("Layer ID (must be a shape visual)"),
+      fill: import_zod18.z.object({
+        type: import_zod18.z.enum(["solid", "linear-gradient", "radial-gradient"]).describe("Fill type"),
+        color: import_zod18.z.unknown().optional().describe("Color for solid fill (hex string or RGBA/HSLA object)"),
+        angle: import_zod18.z.number().optional().describe("Angle in degrees (linear-gradient only)"),
+        center: import_zod18.z.object({
+          x: import_zod18.z.union([import_zod18.z.number(), import_zod18.z.string()]),
+          y: import_zod18.z.union([import_zod18.z.number(), import_zod18.z.string()])
         }).optional().describe("Center point (radial-gradient only)"),
-        radius: import_zod17.z.union([import_zod17.z.number(), import_zod17.z.string()]).optional().describe("Radius (radial-gradient only)"),
-        stops: import_zod17.z.array(import_zod17.z.object({
-          offset: import_zod17.z.number().min(0).max(1),
-          color: import_zod17.z.unknown()
+        radius: import_zod18.z.union([import_zod18.z.number(), import_zod18.z.string()]).optional().describe("Radius (radial-gradient only)"),
+        stops: import_zod18.z.array(import_zod18.z.object({
+          offset: import_zod18.z.number().min(0).max(1),
+          color: import_zod18.z.unknown()
         })).optional().describe("Gradient stops")
       }).describe("Fill definition")
     },
@@ -976,14 +1167,14 @@ function register3(server, store) {
     "atelier_set_stroke",
     "Set the stroke on a shape-type layer",
     {
-      id: import_zod17.z.string().describe("Document ID"),
-      layerId: import_zod17.z.string().describe("Layer ID (must be a shape visual)"),
-      stroke: import_zod17.z.object({
-        color: import_zod17.z.unknown().describe("Stroke color (hex string or RGBA/HSLA object)"),
-        width: import_zod17.z.number().positive().describe("Stroke width in pixels"),
-        dash: import_zod17.z.array(import_zod17.z.number()).optional().describe("Dash pattern"),
-        lineCap: import_zod17.z.enum(["butt", "round", "square"]).optional().describe("Line cap style"),
-        lineJoin: import_zod17.z.enum(["miter", "round", "bevel"]).optional().describe("Line join style")
+      id: import_zod18.z.string().describe("Document ID"),
+      layerId: import_zod18.z.string().describe("Layer ID (must be a shape visual)"),
+      stroke: import_zod18.z.object({
+        color: import_zod18.z.unknown().describe("Stroke color (hex string or RGBA/HSLA object)"),
+        width: import_zod18.z.number().positive().describe("Stroke width in pixels"),
+        dash: import_zod18.z.array(import_zod18.z.number()).optional().describe("Dash pattern"),
+        lineCap: import_zod18.z.enum(["butt", "round", "square"]).optional().describe("Line cap style"),
+        lineJoin: import_zod18.z.enum(["miter", "round", "bevel"]).optional().describe("Line join style")
       }).describe("Stroke definition")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -1001,7 +1192,7 @@ function register3(server, store) {
 }
 
 // ../mcp/src/tools/states.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 function getDoc4(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -1018,11 +1209,11 @@ function register4(server, store) {
     "atelier_add_state",
     "Add a named animation state to a document",
     {
-      id: import_zod18.z.string().describe("Document ID"),
-      stateName: import_zod18.z.string().describe("State name (e.g. 'intro', 'hover', 'exit')"),
-      duration: import_zod18.z.number().positive().int().describe("Duration in frames"),
-      description: import_zod18.z.string().optional().describe("State description"),
-      tags: import_zod18.z.array(import_zod18.z.string()).optional().describe("Tags")
+      id: import_zod19.z.string().describe("Document ID"),
+      stateName: import_zod19.z.string().describe("State name (e.g. 'intro', 'hover', 'exit')"),
+      duration: import_zod19.z.number().positive().int().describe("Duration in frames"),
+      description: import_zod19.z.string().optional().describe("State description"),
+      tags: import_zod19.z.array(import_zod19.z.string()).optional().describe("Tags")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, duration, description, tags }) => {
@@ -1045,11 +1236,11 @@ function register4(server, store) {
     "atelier_edit_state",
     "Edit metadata of an existing animation state",
     {
-      id: import_zod18.z.string().describe("Document ID"),
-      stateName: import_zod18.z.string().describe("State name to edit"),
-      duration: import_zod18.z.number().positive().int().optional().describe("New duration in frames"),
-      description: import_zod18.z.string().optional().describe("New description"),
-      tags: import_zod18.z.array(import_zod18.z.string()).optional().describe("New tags")
+      id: import_zod19.z.string().describe("Document ID"),
+      stateName: import_zod19.z.string().describe("State name to edit"),
+      duration: import_zod19.z.number().positive().int().optional().describe("New duration in frames"),
+      description: import_zod19.z.string().optional().describe("New description"),
+      tags: import_zod19.z.array(import_zod19.z.string()).optional().describe("New tags")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, duration, description, tags }) => {
@@ -1068,8 +1259,8 @@ function register4(server, store) {
     "atelier_remove_state",
     "Remove an animation state and all its deltas",
     {
-      id: import_zod18.z.string().describe("Document ID"),
-      stateName: import_zod18.z.string().describe("State name to remove")
+      id: import_zod19.z.string().describe("Document ID"),
+      stateName: import_zod19.z.string().describe("State name to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, stateName }) => {
@@ -1086,7 +1277,7 @@ function register4(server, store) {
     "atelier_list_states",
     "List all animation states in a document",
     {
-      id: import_zod18.z.string().describe("Document ID")
+      id: import_zod19.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -1106,7 +1297,7 @@ function register4(server, store) {
 }
 
 // ../mcp/src/tools/deltas.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // ../math/dist/index.js
 function linear(t) {
@@ -1662,7 +1853,18 @@ function resolveFrame(doc, stateName, frame, overrideDeltas) {
         }
       }
     }
-    return { id: layer.id, layer, computedProperties };
+    const resolvedLayer = { id: layer.id, layer, computedProperties };
+    if (layer.visual.type === "video") {
+      const video = layer.visual;
+      const fps = doc.canvas.fps;
+      const startFrame = video.startFrame ?? 0;
+      const sourceOffset = video.sourceOffset ?? 0;
+      const playbackRate = video.playbackRate ?? 1;
+      const relativeFrame = Math.max(0, frame - startFrame);
+      const sourceTime = relativeFrame / fps * playbackRate + sourceOffset;
+      resolvedLayer.videoSourceTime = video.sourceEnd !== void 0 ? Math.min(sourceTime, video.sourceEnd) : sourceTime;
+    }
+    return resolvedLayer;
   });
   return { frame, stateName, layers: resolvedLayers };
 }
@@ -1834,17 +2036,17 @@ function register5(server, store) {
     "atelier_add_delta",
     "Add an animation delta (keyframe transition) to a state",
     {
-      id: import_zod19.z.string().describe("Document ID"),
-      stateName: import_zod19.z.string().describe("State name"),
-      layer: import_zod19.z.string().describe("Target layer ID"),
+      id: import_zod20.z.string().describe("Document ID"),
+      stateName: import_zod20.z.string().describe("State name"),
+      layer: import_zod20.z.string().describe("Target layer ID"),
       property: AnimatablePropertyEnum.describe("Property to animate"),
-      range: import_zod19.z.tuple([import_zod19.z.number().int().min(0), import_zod19.z.number().int().min(0)]).describe("Frame range [start, end] inclusive"),
-      from: import_zod19.z.unknown().describe("Starting value"),
-      to: import_zod19.z.unknown().describe("Ending value"),
+      range: import_zod20.z.tuple([import_zod20.z.number().int().min(0), import_zod20.z.number().int().min(0)]).describe("Frame range [start, end] inclusive"),
+      from: import_zod20.z.unknown().describe("Starting value"),
+      to: import_zod20.z.unknown().describe("Ending value"),
       easing: EasingInputSchema.optional().describe("Easing function"),
-      description: import_zod19.z.string().optional().describe("Delta description"),
-      tags: import_zod19.z.array(import_zod19.z.string()).optional().describe("Tags"),
-      deltaId: import_zod19.z.string().optional().describe("Custom delta ID")
+      description: import_zod20.z.string().optional().describe("Delta description"),
+      tags: import_zod20.z.array(import_zod20.z.string()).optional().describe("Tags"),
+      deltaId: import_zod20.z.string().optional().describe("Custom delta ID")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, layer, property, range, from, to, easing, description, tags, deltaId }) => {
@@ -1882,17 +2084,17 @@ function register5(server, store) {
     "atelier_edit_delta",
     "Edit an existing delta by index within a state",
     {
-      id: import_zod19.z.string().describe("Document ID"),
-      stateName: import_zod19.z.string().describe("State name"),
-      deltaIndex: import_zod19.z.number().int().min(0).describe("Delta index within the state"),
-      layer: import_zod19.z.string().optional().describe("New target layer ID"),
+      id: import_zod20.z.string().describe("Document ID"),
+      stateName: import_zod20.z.string().describe("State name"),
+      deltaIndex: import_zod20.z.number().int().min(0).describe("Delta index within the state"),
+      layer: import_zod20.z.string().optional().describe("New target layer ID"),
       property: AnimatablePropertyEnum.optional().describe("New property to animate"),
-      range: import_zod19.z.tuple([import_zod19.z.number().int().min(0), import_zod19.z.number().int().min(0)]).optional().describe("New frame range [start, end]"),
-      from: import_zod19.z.unknown().optional().describe("New starting value"),
-      to: import_zod19.z.unknown().optional().describe("New ending value"),
+      range: import_zod20.z.tuple([import_zod20.z.number().int().min(0), import_zod20.z.number().int().min(0)]).optional().describe("New frame range [start, end]"),
+      from: import_zod20.z.unknown().optional().describe("New starting value"),
+      to: import_zod20.z.unknown().optional().describe("New ending value"),
       easing: EasingInputSchema.optional().describe("New easing function"),
-      description: import_zod19.z.string().optional().describe("New description"),
-      tags: import_zod19.z.array(import_zod19.z.string()).optional().describe("New tags")
+      description: import_zod20.z.string().optional().describe("New description"),
+      tags: import_zod20.z.array(import_zod20.z.string()).optional().describe("New tags")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, deltaIndex, layer, property, range, from, to, easing, description, tags }) => {
@@ -1931,9 +2133,9 @@ function register5(server, store) {
     "atelier_remove_delta",
     "Remove a delta by index from a state",
     {
-      id: import_zod19.z.string().describe("Document ID"),
-      stateName: import_zod19.z.string().describe("State name"),
-      deltaIndex: import_zod19.z.number().int().min(0).describe("Delta index to remove")
+      id: import_zod20.z.string().describe("Document ID"),
+      stateName: import_zod20.z.string().describe("State name"),
+      deltaIndex: import_zod20.z.number().int().min(0).describe("Delta index to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, stateName, deltaIndex }) => {
@@ -1961,12 +2163,12 @@ function register5(server, store) {
     "atelier_apply_preset",
     "Apply a preset to a layer, expanding it into concrete deltas",
     {
-      id: import_zod19.z.string().describe("Document ID"),
-      stateName: import_zod19.z.string().describe("State name to add deltas to"),
-      presetName: import_zod19.z.string().describe("Preset name defined in the document"),
-      layerId: import_zod19.z.string().describe("Target layer ID"),
-      startFrame: import_zod19.z.number().int().min(0).optional().describe("Start frame (default: 0)"),
-      duration: import_zod19.z.number().positive().int().optional().describe("Duration for preset (default: state duration)")
+      id: import_zod20.z.string().describe("Document ID"),
+      stateName: import_zod20.z.string().describe("State name to add deltas to"),
+      presetName: import_zod20.z.string().describe("Preset name defined in the document"),
+      layerId: import_zod20.z.string().describe("Target layer ID"),
+      startFrame: import_zod20.z.number().int().min(0).optional().describe("Start frame (default: 0)"),
+      duration: import_zod20.z.number().positive().int().optional().describe("Duration for preset (default: state duration)")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, presetName, layerId, startFrame, duration }) => {
@@ -2009,7 +2211,7 @@ ${errors.join("\n")}`);
 }
 
 // ../mcp/src/tools/presets.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 function getDoc6(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2023,11 +2225,11 @@ function err6(message) {
 }
 var AnimatablePropertyEnum2 = AnimatablePropertySchema;
 var EasingInputSchema2 = EasingSchema;
-var PresetDeltaSchema2 = import_zod20.z.object({
+var PresetDeltaSchema2 = import_zod21.z.object({
   property: AnimatablePropertyEnum2.describe("Animatable property"),
-  offset: import_zod20.z.tuple([import_zod20.z.number().int().min(0), import_zod20.z.number().int().min(0)]).optional().describe("Relative frame offset [start, end]"),
-  from: import_zod20.z.unknown().describe("Starting value"),
-  to: import_zod20.z.unknown().describe("Ending value"),
+  offset: import_zod21.z.tuple([import_zod21.z.number().int().min(0), import_zod21.z.number().int().min(0)]).optional().describe("Relative frame offset [start, end]"),
+  from: import_zod21.z.unknown().describe("Starting value"),
+  to: import_zod21.z.unknown().describe("Ending value"),
   easing: EasingInputSchema2.optional().describe("Easing function")
 });
 function register6(server, store) {
@@ -2035,11 +2237,11 @@ function register6(server, store) {
     "atelier_define_preset",
     "Define a reusable animation preset on a document",
     {
-      id: import_zod20.z.string().describe("Document ID"),
-      presetName: import_zod20.z.string().describe("Preset name"),
-      description: import_zod20.z.string().optional().describe("Preset description"),
-      tags: import_zod20.z.array(import_zod20.z.string()).optional().describe("Tags"),
-      deltas: import_zod20.z.array(PresetDeltaSchema2).min(1).describe("Array of preset delta definitions")
+      id: import_zod21.z.string().describe("Document ID"),
+      presetName: import_zod21.z.string().describe("Preset name"),
+      description: import_zod21.z.string().optional().describe("Preset description"),
+      tags: import_zod21.z.array(import_zod21.z.string()).optional().describe("Tags"),
+      deltas: import_zod21.z.array(PresetDeltaSchema2).min(1).describe("Array of preset delta definitions")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, presetName, description, tags, deltas }) => {
@@ -2060,7 +2262,7 @@ function register6(server, store) {
     "atelier_list_presets",
     "List all presets defined on a document",
     {
-      id: import_zod20.z.string().describe("Document ID")
+      id: import_zod21.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -2083,7 +2285,7 @@ function register6(server, store) {
 }
 
 // ../mcp/src/tools/preview.ts
-var import_zod21 = require("zod");
+var import_zod22 = require("zod");
 function getDoc7(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2100,7 +2302,7 @@ function register7(server, store) {
     "atelier_validate",
     "Validate an Atelier document for schema correctness and delta overlaps",
     {
-      id: import_zod21.z.string().describe("Document ID")
+      id: import_zod22.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -2129,9 +2331,9 @@ function register7(server, store) {
     "atelier_preview",
     "Preview the resolved state of all layers at a specific frame",
     {
-      id: import_zod21.z.string().describe("Document ID"),
-      stateName: import_zod21.z.string().describe("State name to preview"),
-      frame: import_zod21.z.number().int().min(0).describe("Frame number to resolve")
+      id: import_zod22.z.string().describe("Document ID"),
+      stateName: import_zod22.z.string().describe("State name to preview"),
+      frame: import_zod22.z.number().int().min(0).describe("Frame number to resolve")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frame }) => {
@@ -2166,7 +2368,7 @@ function register7(server, store) {
 }
 
 // ../mcp/src/tools/templates.ts
-var import_zod22 = require("zod");
+var import_zod23 = require("zod");
 function getDoc8(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2183,8 +2385,8 @@ function register8(server, store) {
     "atelier_instantiate_template",
     "Instantiate a template document with variable bindings. Creates a new document in the store.",
     {
-      id: import_zod22.z.string().describe("Template document ID"),
-      bindings: import_zod22.z.record(import_zod22.z.unknown()).describe("Variable bindings: { variableName: value }")
+      id: import_zod23.z.string().describe("Template document ID"),
+      bindings: import_zod23.z.record(import_zod23.z.unknown()).describe("Variable bindings: { variableName: value }")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, bindings }) => {
@@ -2207,7 +2409,7 @@ function register8(server, store) {
     "atelier_find_variables",
     "Scan a document for {{variableName}} patterns. Returns the list of variable references found.",
     {
-      id: import_zod22.z.string().describe("Document ID")
+      id: import_zod23.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -2227,7 +2429,7 @@ function register8(server, store) {
 }
 
 // ../mcp/src/tools/layer-effects.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 function getDoc9(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2244,9 +2446,9 @@ function register9(server, store) {
     "atelier_set_blend_mode",
     "Set or clear the blend mode on a layer",
     {
-      id: import_zod23.z.string().describe("Document ID"),
-      layerId: import_zod23.z.string().describe("Layer ID"),
-      blendMode: import_zod23.z.enum([
+      id: import_zod24.z.string().describe("Document ID"),
+      layerId: import_zod24.z.string().describe("Layer ID"),
+      blendMode: import_zod24.z.enum([
         "normal",
         "multiply",
         "screen",
@@ -2284,13 +2486,13 @@ function register9(server, store) {
     "atelier_set_shadow",
     "Set or remove a drop shadow on a layer",
     {
-      id: import_zod23.z.string().describe("Document ID"),
-      layerId: import_zod23.z.string().describe("Layer ID"),
-      shadow: import_zod23.z.object({
-        color: import_zod23.z.unknown().describe("Shadow color (hex string or RGBA/HSLA object)"),
-        blur: import_zod23.z.number().min(0).describe("Blur radius in pixels"),
-        offsetX: import_zod23.z.number().optional().describe("Horizontal offset in pixels"),
-        offsetY: import_zod23.z.number().optional().describe("Vertical offset in pixels")
+      id: import_zod24.z.string().describe("Document ID"),
+      layerId: import_zod24.z.string().describe("Layer ID"),
+      shadow: import_zod24.z.object({
+        color: import_zod24.z.unknown().describe("Shadow color (hex string or RGBA/HSLA object)"),
+        blur: import_zod24.z.number().min(0).describe("Blur radius in pixels"),
+        offsetX: import_zod24.z.number().optional().describe("Horizontal offset in pixels"),
+        offsetY: import_zod24.z.number().optional().describe("Vertical offset in pixels")
       }).nullable().describe("Shadow definition, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2312,11 +2514,11 @@ function register9(server, store) {
     "atelier_set_tint",
     "Set or remove a color tint on a layer (works on any visual type)",
     {
-      id: import_zod23.z.string().describe("Document ID"),
-      layerId: import_zod23.z.string().describe("Layer ID"),
-      tint: import_zod23.z.object({
-        color: import_zod23.z.string().describe("Tint color (hex string)"),
-        amount: import_zod23.z.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
+      id: import_zod24.z.string().describe("Document ID"),
+      layerId: import_zod24.z.string().describe("Layer ID"),
+      tint: import_zod24.z.object({
+        color: import_zod24.z.string().describe("Tint color (hex string)"),
+        amount: import_zod24.z.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
       }).nullable().describe("Tint definition, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2338,18 +2540,18 @@ function register9(server, store) {
     "atelier_set_motion_path",
     "Set or remove a motion path on a layer for path-based position animation",
     {
-      id: import_zod23.z.string().describe("Document ID"),
-      layerId: import_zod23.z.string().describe("Layer ID"),
-      motionPath: import_zod23.z.object({
-        points: import_zod23.z.array(import_zod23.z.object({
-          x: import_zod23.z.number(),
-          y: import_zod23.z.number(),
-          in: import_zod23.z.object({ x: import_zod23.z.number(), y: import_zod23.z.number() }).optional(),
-          out: import_zod23.z.object({ x: import_zod23.z.number(), y: import_zod23.z.number() }).optional()
+      id: import_zod24.z.string().describe("Document ID"),
+      layerId: import_zod24.z.string().describe("Layer ID"),
+      motionPath: import_zod24.z.object({
+        points: import_zod24.z.array(import_zod24.z.object({
+          x: import_zod24.z.number(),
+          y: import_zod24.z.number(),
+          in: import_zod24.z.object({ x: import_zod24.z.number(), y: import_zod24.z.number() }).optional(),
+          out: import_zod24.z.object({ x: import_zod24.z.number(), y: import_zod24.z.number() }).optional()
         })).min(2).describe("Path points (minimum 2)"),
-        closed: import_zod23.z.boolean().optional().describe("Whether the path is closed"),
-        autoRotate: import_zod23.z.boolean().optional().describe("Auto-rotate layer to follow path tangent"),
-        autoRotateOffset: import_zod23.z.number().optional().describe("Rotation offset in degrees when autoRotate is enabled")
+        closed: import_zod24.z.boolean().optional().describe("Whether the path is closed"),
+        autoRotate: import_zod24.z.boolean().optional().describe("Auto-rotate layer to follow path tangent"),
+        autoRotateOffset: import_zod24.z.number().optional().describe("Rotation offset in degrees when autoRotate is enabled")
       }).nullable().describe("Motion path definition, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2371,21 +2573,21 @@ function register9(server, store) {
     "atelier_set_clip_path",
     "Set or remove a clip path on a layer to restrict rendering to within a shape",
     {
-      id: import_zod23.z.string().describe("Document ID"),
-      layerId: import_zod23.z.string().describe("Layer ID"),
-      clipPath: import_zod23.z.object({
-        type: import_zod23.z.enum(["rect", "ellipse", "path"]).describe("Clip shape type"),
-        cornerRadius: import_zod23.z.union([
-          import_zod23.z.number(),
-          import_zod23.z.tuple([import_zod23.z.number(), import_zod23.z.number(), import_zod23.z.number(), import_zod23.z.number()])
+      id: import_zod24.z.string().describe("Document ID"),
+      layerId: import_zod24.z.string().describe("Layer ID"),
+      clipPath: import_zod24.z.object({
+        type: import_zod24.z.enum(["rect", "ellipse", "path"]).describe("Clip shape type"),
+        cornerRadius: import_zod24.z.union([
+          import_zod24.z.number(),
+          import_zod24.z.tuple([import_zod24.z.number(), import_zod24.z.number(), import_zod24.z.number(), import_zod24.z.number()])
         ]).optional().describe("Corner radius (rect only)"),
-        points: import_zod23.z.array(import_zod23.z.object({
-          x: import_zod23.z.number(),
-          y: import_zod23.z.number(),
-          in: import_zod23.z.object({ x: import_zod23.z.number(), y: import_zod23.z.number() }).optional(),
-          out: import_zod23.z.object({ x: import_zod23.z.number(), y: import_zod23.z.number() }).optional()
+        points: import_zod24.z.array(import_zod24.z.object({
+          x: import_zod24.z.number(),
+          y: import_zod24.z.number(),
+          in: import_zod24.z.object({ x: import_zod24.z.number(), y: import_zod24.z.number() }).optional(),
+          out: import_zod24.z.object({ x: import_zod24.z.number(), y: import_zod24.z.number() }).optional()
         })).optional().describe("Path points (path only)"),
-        closed: import_zod23.z.boolean().optional().describe("Whether path is closed (path only)")
+        closed: import_zod24.z.boolean().optional().describe("Whether path is closed (path only)")
       }).nullable().describe("Clip path shape, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2407,45 +2609,45 @@ function register9(server, store) {
     "atelier_edit_visual",
     "Edit visual content of an existing layer (text content/style, image src/assetId, shape/fill/stroke)",
     {
-      id: import_zod23.z.string().describe("Document ID"),
-      layerId: import_zod23.z.string().describe("Layer ID"),
+      id: import_zod24.z.string().describe("Document ID"),
+      layerId: import_zod24.z.string().describe("Layer ID"),
       // Text fields
-      content: import_zod23.z.string().optional().describe("New text content (text layers only)"),
-      style: import_zod23.z.record(import_zod23.z.unknown()).optional().describe("Partial style update \u2014 only provided keys are overwritten (text layers only)"),
+      content: import_zod24.z.string().optional().describe("New text content (text layers only)"),
+      style: import_zod24.z.record(import_zod24.z.unknown()).optional().describe("Partial style update \u2014 only provided keys are overwritten (text layers only)"),
       // Image fields
-      src: import_zod23.z.string().optional().describe("Image source URL (image layers only)"),
-      assetId: import_zod23.z.string().optional().describe("Asset ID reference (image layers only)"),
-      sourceRect: import_zod23.z.object({
-        x: import_zod23.z.number(),
-        y: import_zod23.z.number(),
-        width: import_zod23.z.number().positive(),
-        height: import_zod23.z.number().positive()
+      src: import_zod24.z.string().optional().describe("Image source URL (image layers only)"),
+      assetId: import_zod24.z.string().optional().describe("Asset ID reference (image layers only)"),
+      sourceRect: import_zod24.z.object({
+        x: import_zod24.z.number(),
+        y: import_zod24.z.number(),
+        width: import_zod24.z.number().positive(),
+        height: import_zod24.z.number().positive()
       }).nullable().optional().describe("Source rectangle crop (image layers only). Null to remove."),
-      spritesheet: import_zod23.z.object({
-        columns: import_zod23.z.number().int().positive(),
-        rows: import_zod23.z.number().int().positive(),
-        frameCount: import_zod23.z.number().int().positive().optional(),
-        frameWidth: import_zod23.z.number().positive(),
-        frameHeight: import_zod23.z.number().positive()
+      spritesheet: import_zod24.z.object({
+        columns: import_zod24.z.number().int().positive(),
+        rows: import_zod24.z.number().int().positive(),
+        frameCount: import_zod24.z.number().int().positive().optional(),
+        frameWidth: import_zod24.z.number().positive(),
+        frameHeight: import_zod24.z.number().positive()
       }).nullable().optional().describe("Spritesheet config (image layers only). Null to remove."),
-      frameIndex: import_zod23.z.number().int().min(0).optional().describe("Spritesheet frame index (image layers only)"),
+      frameIndex: import_zod24.z.number().int().min(0).optional().describe("Spritesheet frame index (image layers only)"),
       // Shape fields
-      shape: import_zod23.z.object({
-        type: import_zod23.z.enum(["rect", "ellipse", "path"]),
-        cornerRadius: import_zod23.z.union([
-          import_zod23.z.number(),
-          import_zod23.z.tuple([import_zod23.z.number(), import_zod23.z.number(), import_zod23.z.number(), import_zod23.z.number()])
+      shape: import_zod24.z.object({
+        type: import_zod24.z.enum(["rect", "ellipse", "path"]),
+        cornerRadius: import_zod24.z.union([
+          import_zod24.z.number(),
+          import_zod24.z.tuple([import_zod24.z.number(), import_zod24.z.number(), import_zod24.z.number(), import_zod24.z.number()])
         ]).optional(),
-        points: import_zod23.z.array(import_zod23.z.object({
-          x: import_zod23.z.number(),
-          y: import_zod23.z.number(),
-          in: import_zod23.z.object({ x: import_zod23.z.number(), y: import_zod23.z.number() }).optional(),
-          out: import_zod23.z.object({ x: import_zod23.z.number(), y: import_zod23.z.number() }).optional()
+        points: import_zod24.z.array(import_zod24.z.object({
+          x: import_zod24.z.number(),
+          y: import_zod24.z.number(),
+          in: import_zod24.z.object({ x: import_zod24.z.number(), y: import_zod24.z.number() }).optional(),
+          out: import_zod24.z.object({ x: import_zod24.z.number(), y: import_zod24.z.number() }).optional()
         })).optional(),
-        closed: import_zod23.z.boolean().optional()
+        closed: import_zod24.z.boolean().optional()
       }).optional().describe("New shape (shape layers only)"),
-      fill: import_zod23.z.record(import_zod23.z.unknown()).optional().describe("New fill definition (shape layers only)"),
-      stroke: import_zod23.z.record(import_zod23.z.unknown()).optional().describe("New stroke definition (shape layers only)")
+      fill: import_zod24.z.record(import_zod24.z.unknown()).optional().describe("New fill definition (shape layers only)"),
+      stroke: import_zod24.z.record(import_zod24.z.unknown()).optional().describe("New stroke definition (shape layers only)")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, content, style, src, assetId, sourceRect, spritesheet, frameIndex, shape, fill, stroke }) => {
@@ -2526,7 +2728,7 @@ function register9(server, store) {
 }
 
 // ../mcp/src/tools/state-config.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 function getDoc10(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2538,27 +2740,27 @@ function ok10(data) {
 function err10(message) {
   return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
 }
-var EasingInputSchema3 = import_zod24.z.union([
-  import_zod24.z.enum(["ease-in", "ease-out", "ease-in-out"]),
-  import_zod24.z.object({ type: import_zod24.z.literal("linear") }),
-  import_zod24.z.object({
-    type: import_zod24.z.literal("cubic-bezier"),
-    x1: import_zod24.z.number(),
-    y1: import_zod24.z.number(),
-    x2: import_zod24.z.number(),
-    y2: import_zod24.z.number()
+var EasingInputSchema3 = import_zod25.z.union([
+  import_zod25.z.enum(["ease-in", "ease-out", "ease-in-out"]),
+  import_zod25.z.object({ type: import_zod25.z.literal("linear") }),
+  import_zod25.z.object({
+    type: import_zod25.z.literal("cubic-bezier"),
+    x1: import_zod25.z.number(),
+    y1: import_zod25.z.number(),
+    x2: import_zod25.z.number(),
+    y2: import_zod25.z.number()
   }),
-  import_zod24.z.object({
-    type: import_zod24.z.literal("spring"),
-    mass: import_zod24.z.number().optional(),
-    stiffness: import_zod24.z.number().optional(),
-    damping: import_zod24.z.number().optional(),
-    velocity: import_zod24.z.number().optional()
+  import_zod25.z.object({
+    type: import_zod25.z.literal("spring"),
+    mass: import_zod25.z.number().optional(),
+    stiffness: import_zod25.z.number().optional(),
+    damping: import_zod25.z.number().optional(),
+    velocity: import_zod25.z.number().optional()
   }),
-  import_zod24.z.object({
-    type: import_zod24.z.literal("step"),
-    steps: import_zod24.z.number().int().positive(),
-    position: import_zod24.z.enum(["start", "end"]).optional()
+  import_zod25.z.object({
+    type: import_zod25.z.literal("step"),
+    steps: import_zod25.z.number().int().positive(),
+    position: import_zod25.z.enum(["start", "end"]).optional()
   })
 ]).describe("Easing function");
 function register10(server, store) {
@@ -2566,14 +2768,14 @@ function register10(server, store) {
     "atelier_set_audio",
     "Set or remove an audio track on a state",
     {
-      id: import_zod24.z.string().describe("Document ID"),
-      stateName: import_zod24.z.string().describe("State name"),
-      audio: import_zod24.z.object({
-        src: import_zod24.z.string().describe("Audio source \u2014 asset reference, file path, or URL"),
-        offset: import_zod24.z.number().min(0).optional().describe("Skip into audio in seconds (default: 0)"),
-        volume: import_zod24.z.number().min(0).max(1).optional().describe("Playback volume 0\u20131 (default: 1)"),
-        loop: import_zod24.z.boolean().optional().describe("Loop for state duration (default: false)"),
-        startFrame: import_zod24.z.number().int().min(0).optional().describe("Frame to start playing (default: 0)")
+      id: import_zod25.z.string().describe("Document ID"),
+      stateName: import_zod25.z.string().describe("State name"),
+      audio: import_zod25.z.object({
+        src: import_zod25.z.string().describe("Audio source \u2014 asset reference, file path, or URL"),
+        offset: import_zod25.z.number().min(0).optional().describe("Skip into audio in seconds (default: 0)"),
+        volume: import_zod25.z.number().min(0).max(1).optional().describe("Playback volume 0\u20131 (default: 1)"),
+        loop: import_zod25.z.boolean().optional().describe("Loop for state duration (default: false)"),
+        startFrame: import_zod25.z.number().int().min(0).optional().describe("Frame to start playing (default: 0)")
       }).nullable().describe("Audio configuration, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2595,11 +2797,11 @@ function register10(server, store) {
     "atelier_configure_transition",
     "Configure or remove a transition from one state to a target state",
     {
-      id: import_zod24.z.string().describe("Document ID"),
-      stateName: import_zod24.z.string().describe("Source state name"),
-      targetState: import_zod24.z.string().describe("Target state name"),
-      transition: import_zod24.z.object({
-        duration: import_zod24.z.number().positive().int().describe("Transition duration in frames"),
+      id: import_zod25.z.string().describe("Document ID"),
+      stateName: import_zod25.z.string().describe("Source state name"),
+      targetState: import_zod25.z.string().describe("Target state name"),
+      transition: import_zod25.z.object({
+        duration: import_zod25.z.number().positive().int().describe("Transition duration in frames"),
         easing: EasingInputSchema3.optional()
       }).nullable().describe("Transition config, or null to remove")
     },
@@ -2636,9 +2838,9 @@ function register10(server, store) {
     "atelier_set_state_parent",
     "Set or clear the parent state for hierarchical delta inheritance",
     {
-      id: import_zod24.z.string().describe("Document ID"),
-      stateName: import_zod24.z.string().describe("State name"),
-      parent: import_zod24.z.string().nullable().describe("Parent state name, or null to clear")
+      id: import_zod25.z.string().describe("Document ID"),
+      stateName: import_zod25.z.string().describe("State name"),
+      parent: import_zod25.z.string().nullable().describe("Parent state name, or null to clear")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, parent }) => {
@@ -2673,7 +2875,7 @@ function register10(server, store) {
 }
 
 // ../mcp/src/tools/export.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // ../canvas/dist/index.js
 function colorToCSS(color) {
@@ -3858,12 +4060,12 @@ function register11(server, store) {
     "atelier_export_svg",
     "Export a frame as an SVG string",
     {
-      id: import_zod25.z.string().describe("Document ID"),
-      stateName: import_zod25.z.string().optional().describe("State name (defaults to first state)"),
-      frame: import_zod25.z.number().int().min(0).optional().describe("Frame number (defaults to 0)"),
-      xmlDeclaration: import_zod25.z.boolean().optional().describe("Include XML declaration (default: false)"),
-      viewBox: import_zod25.z.boolean().optional().describe("Include viewBox attribute (default: true)"),
-      indent: import_zod25.z.number().int().min(0).optional().describe("Indent size in spaces (default: 2)")
+      id: import_zod26.z.string().describe("Document ID"),
+      stateName: import_zod26.z.string().optional().describe("State name (defaults to first state)"),
+      frame: import_zod26.z.number().int().min(0).optional().describe("Frame number (defaults to 0)"),
+      xmlDeclaration: import_zod26.z.boolean().optional().describe("Include XML declaration (default: false)"),
+      viewBox: import_zod26.z.boolean().optional().describe("Include viewBox attribute (default: true)"),
+      indent: import_zod26.z.number().int().min(0).optional().describe("Indent size in spaces (default: 2)")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frame, xmlDeclaration, viewBox, indent }) => {
@@ -3894,8 +4096,8 @@ function register11(server, store) {
     "atelier_export_lottie",
     "Export a document to Lottie JSON format (lossy, best-effort)",
     {
-      id: import_zod25.z.string().describe("Document ID"),
-      stateName: import_zod25.z.string().optional().describe("State to export (defaults to first state)")
+      id: import_zod26.z.string().describe("Document ID"),
+      stateName: import_zod26.z.string().optional().describe("State to export (defaults to first state)")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName }) => {
@@ -3915,7 +4117,7 @@ function register11(server, store) {
 }
 
 // ../mcp/src/tools/assets.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 function getDoc12(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -3932,17 +4134,17 @@ function register12(server, store) {
     "atelier_add_asset",
     "Register an external asset (image, SVG, font, animation, audio) on a document",
     {
-      id: import_zod26.z.string().describe("Document ID"),
-      assetId: import_zod26.z.string().describe("Unique asset identifier"),
-      type: import_zod26.z.enum(["image", "svg", "font", "animation", "audio"]).describe("Asset type"),
-      src: import_zod26.z.string().describe("File path or URL"),
-      description: import_zod26.z.string().optional().describe("Human-readable description"),
-      spritesheet: import_zod26.z.object({
-        columns: import_zod26.z.number().int().positive().describe("Number of columns in the spritesheet grid"),
-        rows: import_zod26.z.number().int().positive().describe("Number of rows in the spritesheet grid"),
-        frameCount: import_zod26.z.number().int().positive().optional().describe("Total frame count (defaults to columns \xD7 rows)"),
-        frameWidth: import_zod26.z.number().positive().describe("Width of each frame in pixels"),
-        frameHeight: import_zod26.z.number().positive().describe("Height of each frame in pixels")
+      id: import_zod27.z.string().describe("Document ID"),
+      assetId: import_zod27.z.string().describe("Unique asset identifier"),
+      type: import_zod27.z.enum(["image", "svg", "font", "animation", "audio"]).describe("Asset type"),
+      src: import_zod27.z.string().describe("File path or URL"),
+      description: import_zod27.z.string().optional().describe("Human-readable description"),
+      spritesheet: import_zod27.z.object({
+        columns: import_zod27.z.number().int().positive().describe("Number of columns in the spritesheet grid"),
+        rows: import_zod27.z.number().int().positive().describe("Number of rows in the spritesheet grid"),
+        frameCount: import_zod27.z.number().int().positive().optional().describe("Total frame count (defaults to columns \xD7 rows)"),
+        frameWidth: import_zod27.z.number().positive().describe("Width of each frame in pixels"),
+        frameHeight: import_zod27.z.number().positive().describe("Height of each frame in pixels")
       }).optional().describe("Spritesheet metadata (image assets only)")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -3965,7 +4167,7 @@ function register12(server, store) {
     "atelier_list_assets",
     "List all registered assets with usage info (which layers/states reference them)",
     {
-      id: import_zod26.z.string().describe("Document ID")
+      id: import_zod27.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -3992,8 +4194,8 @@ function register12(server, store) {
     "atelier_remove_asset",
     "Remove a registered asset. Warns if layers or state audio still reference it.",
     {
-      id: import_zod26.z.string().describe("Document ID"),
-      assetId: import_zod26.z.string().describe("Asset ID to remove")
+      id: import_zod27.z.string().describe("Document ID"),
+      assetId: import_zod27.z.string().describe("Asset ID to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, assetId }) => {
@@ -4017,7 +4219,7 @@ function register12(server, store) {
 }
 
 // ../mcp/src/tools/variables.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 function getDoc13(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4034,11 +4236,11 @@ function register13(server, store) {
     "atelier_add_variable",
     "Define a template variable on a document",
     {
-      id: import_zod27.z.string().describe("Document ID"),
-      variableName: import_zod27.z.string().describe("Variable name (used in {{variableName}} patterns)"),
-      type: import_zod27.z.enum(["string", "number", "color", "asset", "boolean"]).describe("Variable type"),
-      description: import_zod27.z.string().optional().describe("Human-readable description"),
-      default: import_zod27.z.unknown().optional().describe("Default value")
+      id: import_zod28.z.string().describe("Document ID"),
+      variableName: import_zod28.z.string().describe("Variable name (used in {{variableName}} patterns)"),
+      type: import_zod28.z.enum(["string", "number", "color", "asset", "boolean"]).describe("Variable type"),
+      description: import_zod28.z.string().optional().describe("Human-readable description"),
+      default: import_zod28.z.unknown().optional().describe("Default value")
     },
     { readOnlyHint: false, destructiveHint: false },
     async (args) => {
@@ -4059,7 +4261,7 @@ function register13(server, store) {
     "atelier_list_variables",
     "List all declared variables with usage info (which {{references}} exist in the document)",
     {
-      id: import_zod27.z.string().describe("Document ID")
+      id: import_zod28.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -4083,8 +4285,8 @@ function register13(server, store) {
     "atelier_remove_variable",
     "Remove a declared variable. Warns if {{references}} still exist in the document.",
     {
-      id: import_zod27.z.string().describe("Document ID"),
-      variableName: import_zod27.z.string().describe("Variable name to remove")
+      id: import_zod28.z.string().describe("Document ID"),
+      variableName: import_zod28.z.string().describe("Variable name to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, variableName }) => {
@@ -4107,7 +4309,7 @@ function register13(server, store) {
 }
 
 // ../mcp/src/tools/interactions.ts
-var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 function getDoc14(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4124,23 +4326,23 @@ function register14(server, store) {
     "atelier_add_interaction",
     "Add a trigger-action interaction to a layer (click, hover, timer, signal \u2192 go-to-state, emit-signal, set-variable, toggle-visibility)",
     {
-      id: import_zod28.z.string().describe("Document ID"),
-      layerId: import_zod28.z.string().describe("Layer to attach the interaction to"),
-      interactionId: import_zod28.z.string().describe("Unique interaction ID"),
-      trigger: import_zod28.z.object({
-        type: import_zod28.z.enum(["click", "hover", "pointerdown", "pointerup", "timer", "signal"]).describe("Trigger type"),
-        delay: import_zod28.z.number().optional().describe("Delay in ms (timer trigger only)"),
-        signal: import_zod28.z.string().optional().describe("Signal name (signal trigger only)")
+      id: import_zod29.z.string().describe("Document ID"),
+      layerId: import_zod29.z.string().describe("Layer to attach the interaction to"),
+      interactionId: import_zod29.z.string().describe("Unique interaction ID"),
+      trigger: import_zod29.z.object({
+        type: import_zod29.z.enum(["click", "hover", "pointerdown", "pointerup", "timer", "signal"]).describe("Trigger type"),
+        delay: import_zod29.z.number().optional().describe("Delay in ms (timer trigger only)"),
+        signal: import_zod29.z.string().optional().describe("Signal name (signal trigger only)")
       }).describe("What triggers the interaction"),
-      action: import_zod28.z.object({
-        type: import_zod28.z.enum(["go-to-state", "emit-signal", "set-variable", "toggle-visibility"]).describe("Action type"),
-        state: import_zod28.z.string().optional().describe("Target state (go-to-state only)"),
-        signal: import_zod28.z.string().optional().describe("Signal to emit (emit-signal only)"),
-        variable: import_zod28.z.string().optional().describe("Variable name (set-variable only)"),
-        value: import_zod28.z.unknown().optional().describe("Value to set (set-variable only)"),
-        targetLayer: import_zod28.z.string().optional().describe("Target layer ID (toggle-visibility, defaults to self)")
+      action: import_zod29.z.object({
+        type: import_zod29.z.enum(["go-to-state", "emit-signal", "set-variable", "toggle-visibility"]).describe("Action type"),
+        state: import_zod29.z.string().optional().describe("Target state (go-to-state only)"),
+        signal: import_zod29.z.string().optional().describe("Signal to emit (emit-signal only)"),
+        variable: import_zod29.z.string().optional().describe("Variable name (set-variable only)"),
+        value: import_zod29.z.unknown().optional().describe("Value to set (set-variable only)"),
+        targetLayer: import_zod29.z.string().optional().describe("Target layer ID (toggle-visibility, defaults to self)")
       }).describe("What happens when triggered"),
-      description: import_zod28.z.string().optional().describe("Human-readable description")
+      description: import_zod29.z.string().optional().describe("Human-readable description")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, interactionId, trigger, action, description }) => {
@@ -4189,8 +4391,8 @@ function register14(server, store) {
     "atelier_list_interactions",
     "List all interactions across all layers or for a specific layer",
     {
-      id: import_zod28.z.string().describe("Document ID"),
-      layerId: import_zod28.z.string().optional().describe("Optional: filter to a specific layer")
+      id: import_zod29.z.string().describe("Document ID"),
+      layerId: import_zod29.z.string().optional().describe("Optional: filter to a specific layer")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, layerId }) => {
@@ -4217,9 +4419,9 @@ function register14(server, store) {
     "atelier_remove_interaction",
     "Remove an interaction from a layer",
     {
-      id: import_zod28.z.string().describe("Document ID"),
-      layerId: import_zod28.z.string().describe("Layer ID"),
-      interactionId: import_zod28.z.string().describe("Interaction ID to remove")
+      id: import_zod29.z.string().describe("Document ID"),
+      layerId: import_zod29.z.string().describe("Layer ID"),
+      interactionId: import_zod29.z.string().describe("Interaction ID to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, layerId, interactionId }) => {
@@ -4241,7 +4443,7 @@ function register14(server, store) {
 }
 
 // ../mcp/src/tools/refs.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 function getDoc15(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4258,9 +4460,9 @@ function register15(server, store) {
     "atelier_set_ref",
     "Set the source reference on a ref-type layer. Can point to a file path or another in-memory document ID.",
     {
-      id: import_zod29.z.string().describe("Document ID"),
-      layerId: import_zod29.z.string().describe("Layer ID (must be a ref visual)"),
-      src: import_zod29.z.string().describe("File path, URL, or in-memory document ID")
+      id: import_zod30.z.string().describe("Document ID"),
+      layerId: import_zod30.z.string().describe("Layer ID (must be a ref visual)"),
+      src: import_zod30.z.string().describe("File path, URL, or in-memory document ID")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, src }) => {
@@ -4280,7 +4482,7 @@ function register15(server, store) {
     "atelier_resolve_refs",
     "Check which ref layers can be resolved (point to valid in-memory documents)",
     {
-      id: import_zod29.z.string().describe("Document ID")
+      id: import_zod30.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -4307,7 +4509,7 @@ function register15(server, store) {
 }
 
 // ../mcp/src/tools/performance.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 function getDoc16(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4324,9 +4526,9 @@ function register16(server, store) {
     "atelier_profile",
     "Profile frame resolution performance \u2014 returns timing, layer count, property count, and delta count for a frame",
     {
-      id: import_zod30.z.string().describe("Document ID"),
-      stateName: import_zod30.z.string().describe("State name to profile"),
-      frame: import_zod30.z.number().int().min(0).describe("Frame number to resolve")
+      id: import_zod31.z.string().describe("Document ID"),
+      stateName: import_zod31.z.string().describe("State name to profile"),
+      frame: import_zod31.z.number().int().min(0).describe("Frame number to resolve")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frame }) => {
@@ -4372,10 +4574,10 @@ function register16(server, store) {
     "atelier_diff_frames",
     "Compare two frames and return only the properties that changed between them",
     {
-      id: import_zod30.z.string().describe("Document ID"),
-      stateName: import_zod30.z.string().describe("State name"),
-      frameA: import_zod30.z.number().int().min(0).describe("First frame number"),
-      frameB: import_zod30.z.number().int().min(0).describe("Second frame number")
+      id: import_zod31.z.string().describe("Document ID"),
+      stateName: import_zod31.z.string().describe("State name"),
+      frameA: import_zod31.z.number().int().min(0).describe("First frame number"),
+      frameB: import_zod31.z.number().int().min(0).describe("Second frame number")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frameA, frameB }) => {
@@ -4414,9 +4616,9 @@ function register16(server, store) {
     "atelier_batch_preview",
     "Preview multiple frames at once \u2014 reduces round-trips for scrubbing or timeline inspection",
     {
-      id: import_zod30.z.string().describe("Document ID"),
-      stateName: import_zod30.z.string().describe("State name to preview"),
-      frames: import_zod30.z.array(import_zod30.z.number().int().min(0)).min(1).max(60).describe("Array of frame numbers to resolve (max 60)")
+      id: import_zod31.z.string().describe("Document ID"),
+      stateName: import_zod31.z.string().describe("State name to preview"),
+      frames: import_zod31.z.array(import_zod31.z.number().int().min(0)).min(1).max(60).describe("Array of frame numbers to resolve (max 60)")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frames }) => {
@@ -4452,7 +4654,7 @@ function register16(server, store) {
     "atelier_complexity",
     "Analyze document complexity \u2014 layer count, delta count, expression usage, state hierarchy depth",
     {
-      id: import_zod30.z.string().describe("Document ID")
+      id: import_zod31.z.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -4524,9 +4726,678 @@ function register16(server, store) {
   );
 }
 
+// ../mcp/src/tools/overlays.ts
+var import_zod32 = require("zod");
+function getDoc17(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok17(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err17(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+var AnchorEnum = import_zod32.z.enum(["top-left", "top-right", "bottom-left", "bottom-right"]);
+var OverlayStyleSchema = import_zod32.z.object({
+  font_family: import_zod32.z.string().optional(),
+  font_size: import_zod32.z.number().positive().optional(),
+  font_weight: import_zod32.z.union([import_zod32.z.number(), import_zod32.z.enum(["normal", "bold"])]).optional(),
+  color: import_zod32.z.string().optional()
+}).optional();
+var DEFAULT_OVERLAY_MARGIN = 24;
+var DEFAULT_TEXT_STYLE = {
+  fontFamily: "Inter",
+  fontSize: 24,
+  fontWeight: 600,
+  color: "#F5F5F7"
+};
+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 mergeStyle(style) {
+  return {
+    fontFamily: style?.font_family ?? DEFAULT_TEXT_STYLE.fontFamily,
+    fontSize: style?.font_size ?? DEFAULT_TEXT_STYLE.fontSize,
+    fontWeight: style?.font_weight ?? DEFAULT_TEXT_STYLE.fontWeight,
+    color: style?.color ?? DEFAULT_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;
+    }
+  );
+}
+function register17(server, store) {
+  server.tool(
+    "atelier_add_handle",
+    "Add an anchored creator-handle TextVisual overlay layer (tag: overlay)",
+    {
+      id: import_zod32.z.string().describe("Document ID"),
+      text: import_zod32.z.string().min(1).describe('Handle text, e.g. "@username"'),
+      anchor: AnchorEnum.describe("Anchored corner"),
+      margin: import_zod32.z.number().nonnegative().optional().describe("Px from anchored edges (default 24)"),
+      style: OverlayStyleSchema.describe("Text style overrides (snake_case to match recipe)"),
+      layerId: import_zod32.z.string().optional().describe("Layer ID (default: overlay-handle)")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ id, text, anchor, margin, style, layerId }) => {
+      const result = getDoc17(store, id);
+      if ("error" in result) return err17(result.error);
+      const { doc } = result;
+      const targetId = layerId ?? "overlay-handle";
+      if (doc.layers.some((l) => l.id === targetId)) {
+        return err17(`Layer "${targetId}" already exists in document "${id}"`);
+      }
+      const m = margin ?? DEFAULT_OVERLAY_MARGIN;
+      const { frame, anchorPoint } = anchorToFrame(anchor, doc.canvas, m);
+      const layer = {
+        id: targetId,
+        tags: ["overlay"],
+        visual: { type: "text", content: text, style: mergeStyle(style) },
+        frame,
+        bounds: { width: 600, height: 80 },
+        anchorPoint
+      };
+      doc.layers.push(layer);
+      store.set(id, doc);
+      return ok17({ layerId: targetId, layer });
+    }
+  );
+  server.tool(
+    "atelier_add_page_number",
+    "Add an anchored page-number TextVisual overlay layer (tag: overlay). Substitutes {current} / {total} (and zero-pad forms {current:02d} / {total:02d}) into format.",
+    {
+      id: import_zod32.z.string().describe("Document ID"),
+      format: import_zod32.z.string().min(1).describe('Format string, e.g. "{current}/{total}" or "{current:02d}/{total:02d}"'),
+      anchor: AnchorEnum.describe("Anchored corner"),
+      currentIndex: import_zod32.z.number().int().nonnegative().describe("1-based current index"),
+      totalCount: import_zod32.z.number().int().positive().describe("Total count"),
+      margin: import_zod32.z.number().nonnegative().optional().describe("Px from anchored edges (default 24)"),
+      style: OverlayStyleSchema.describe("Text style overrides (snake_case to match recipe)"),
+      layerId: import_zod32.z.string().optional().describe("Layer ID (default: overlay-page-number)")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ id, format, anchor, currentIndex, totalCount, margin, style, layerId }) => {
+      const result = getDoc17(store, id);
+      if ("error" in result) return err17(result.error);
+      const { doc } = result;
+      const targetId = layerId ?? "overlay-page-number";
+      if (doc.layers.some((l) => l.id === targetId)) {
+        return err17(`Layer "${targetId}" already exists in document "${id}"`);
+      }
+      const content = renderPageNumberFormat(format, currentIndex, totalCount);
+      const m = margin ?? DEFAULT_OVERLAY_MARGIN;
+      const { frame, anchorPoint } = anchorToFrame(anchor, doc.canvas, m);
+      const layer = {
+        id: targetId,
+        tags: ["overlay"],
+        visual: { type: "text", content, style: mergeStyle(style) },
+        frame,
+        bounds: { width: 200, height: 80 },
+        anchorPoint
+      };
+      doc.layers.push(layer);
+      store.set(id, doc);
+      return ok17({ layerId: targetId, layer, rendered: content });
+    }
+  );
+}
+
+// ../mcp/src/tools/recipes.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var import_zod33 = require("zod");
+var import_yaml2 = require("yaml");
+function getDoc18(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok18(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err18(message, extra) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message, ...extra }) }],
+    isError: true
+  };
+}
+function resolveRecipePath(pathOrName, projectDir) {
+  if ((0, import_node_path.isAbsolute)(pathOrName) || pathOrName.includes("/") || pathOrName.includes("\\")) {
+    return (0, import_node_path.resolve)(pathOrName);
+  }
+  const candidates = [];
+  const exts = [".recipe.yaml", ".recipe.json", ".yaml", ".yml", ".json"];
+  const projectRecipesDir = (0, import_node_path.join)((0, import_node_path.resolve)(projectDir), ".atelier", "recipes");
+  for (const ext of exts) candidates.push((0, import_node_path.join)(projectRecipesDir, `${pathOrName}${ext}`));
+  const userRecipesDir = (0, import_node_path.join)((0, import_node_os.homedir)(), ".atelier", "recipes");
+  for (const ext of exts) candidates.push((0, import_node_path.join)(userRecipesDir, `${pathOrName}${ext}`));
+  for (const candidate of candidates) {
+    if ((0, import_node_fs.existsSync)(candidate)) return candidate;
+  }
+  throw new Error(
+    `Recipe "${pathOrName}" not found. Looked in:
+${candidates.map((c) => `  ${c}`).join("\n")}`
+  );
+}
+function parseRecipeText(raw, path) {
+  if (path.endsWith(".json")) return JSON.parse(raw);
+  return (0, import_yaml2.parse)(raw);
+}
+function loadRecipe(pathOrName, projectDir) {
+  const path = resolveRecipePath(pathOrName, projectDir);
+  const raw = (0, import_node_fs.readFileSync)(path, "utf-8");
+  const parsed = parseRecipeText(raw, path);
+  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 recipeToYaml(recipe) {
+  return (0, import_yaml2.stringify)(recipe);
+}
+var DEFAULT_OVERLAY_MARGIN2 = 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 warnings = [];
+  const rules = recipe.overlay_rules;
+  if (!rules) {
+    return { doc: { ...doc, layers: preserved }, warnings };
+  }
+  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 {
+      warnings.push(
+        "recipe.overlay_rules.page_number is present but currentIndex/totalCount were not provided \u2014 the page_number layer was skipped."
+      );
+    }
+  }
+  return { doc: { ...doc, layers: [...preserved, ...overlayLayers] }, warnings };
+}
+function buildHandleLayer(rule, canvas) {
+  const margin = rule.margin ?? DEFAULT_OVERLAY_MARGIN2;
+  const { frame, anchorPoint } = anchorToFrame2(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_MARGIN2;
+  const { frame, anchorPoint } = anchorToFrame2(rule.anchor, canvas, margin);
+  return {
+    id: PAGE_NUMBER_LAYER_ID,
+    tags: ["overlay"],
+    visual: {
+      type: "text",
+      content: renderPageNumberFormat2(rule.format, currentIndex, totalCount),
+      style: mergeOverlayStyle(rule.style)
+    },
+    frame,
+    bounds: { width: 200, height: 80 },
+    anchorPoint
+  };
+}
+function anchorToFrame2(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 renderPageNumberFormat2(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) return str.padStart(parseInt(padWidth, 10), "0");
+      return str;
+    }
+  );
+}
+var RECIPE_EXTS = [".recipe.yaml", ".recipe.yml", ".recipe.json"];
+function isRecipeFile(name) {
+  return RECIPE_EXTS.some((ext) => name.endsWith(ext));
+}
+function listRecipesIn(dir) {
+  if (!(0, import_node_fs.existsSync)(dir)) return [];
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir);
+  } catch {
+    return [];
+  }
+  return entries.filter(isRecipeFile).map((name) => ({ name, path: (0, import_node_path.join)(dir, name) })).sort((a, b) => a.name.localeCompare(b.name));
+}
+function register18(server, store) {
+  server.tool(
+    "atelier_recipe_list",
+    "List discoverable Studio Recipes \u2014 project-local <projectDir>/.atelier/recipes/*.recipe.* plus ~/.atelier/recipes/*.recipe.*. Returns { name, path } entries with absolute paths.",
+    {
+      projectDir: import_zod33.z.string().optional().describe("Project root to search (default: process.cwd())")
+    },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ projectDir }) => {
+      const root = (0, import_node_path.resolve)(projectDir ?? process.cwd());
+      const projectRecipes = listRecipesIn((0, import_node_path.join)(root, ".atelier", "recipes"));
+      const userRecipes = listRecipesIn((0, import_node_path.join)((0, import_node_os.homedir)(), ".atelier", "recipes"));
+      const seen = new Set(projectRecipes.map((r) => r.name));
+      const recipes = [...projectRecipes, ...userRecipes.filter((r) => !seen.has(r.name))];
+      return ok18({ count: recipes.length, recipes });
+    }
+  );
+  server.tool(
+    "atelier_recipe_get",
+    "Load a recipe and return BOTH the parsed object and its serialized YAML text (so the agent can show/explain it), plus any validation warnings.",
+    {
+      path: import_zod33.z.string().describe("Recipe path or bare name (resolved like the CLI)"),
+      projectDir: import_zod33.z.string().optional().describe("Project root for name resolution (default: process.cwd())")
+    },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ path, projectDir }) => {
+      const root = (0, import_node_path.resolve)(projectDir ?? process.cwd());
+      try {
+        const loaded = loadRecipe(path, root);
+        return ok18({
+          path: loaded.path,
+          recipe: loaded.recipe,
+          yaml: recipeToYaml(loaded.recipe),
+          warnings: loaded.warnings
+        });
+      } catch (e) {
+        return err18(e.message);
+      }
+    }
+  );
+  server.tool(
+    "atelier_recipe_validate",
+    "Validate a recipe from a path OR inline YAML text. Returns { success, warnings, errors }.",
+    {
+      path: import_zod33.z.string().optional().describe("Recipe path or bare name to validate"),
+      yaml: import_zod33.z.string().optional().describe("Inline YAML text to validate (alternative to path)"),
+      projectDir: import_zod33.z.string().optional().describe("Project root for name resolution (default: process.cwd())")
+    },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ path, yaml, projectDir }) => {
+      if (!path && yaml === void 0) {
+        return err18("Provide either `path` or `yaml` to validate");
+      }
+      const root = (0, import_node_path.resolve)(projectDir ?? process.cwd());
+      let parsed;
+      try {
+        if (yaml !== void 0) {
+          parsed = (0, import_yaml2.parse)(yaml);
+        } else {
+          const resolved = resolveRecipePath(path, root);
+          parsed = parseRecipeText((0, import_node_fs.readFileSync)(resolved, "utf-8"), resolved);
+        }
+      } catch (e) {
+        return ok18({ valid: false, warnings: [], errors: [{ path: "(yaml)", message: e.message }] });
+      }
+      const result = validateRecipe(parsed);
+      if (!result.success) {
+        return ok18({ valid: false, warnings: [], errors: result.errors });
+      }
+      return ok18({ valid: true, warnings: result.warnings ?? [], errors: [] });
+    }
+  );
+  server.tool(
+    "atelier_recipe_save",
+    "Write a recipe to disk. Accepts a recipe object (serialized via YAML) OR raw YAML text. Validates BEFORE writing and REFUSES to write an invalid recipe (returns an error with the validation issues). Creates parent directories as needed.",
+    {
+      path: import_zod33.z.string().describe("Absolute or relative file path to write the recipe to"),
+      recipe: import_zod33.z.record(import_zod33.z.unknown()).optional().describe("Recipe object (will be serialized to YAML)"),
+      yaml: import_zod33.z.string().optional().describe("Raw YAML text (alternative to `recipe`)")
+    },
+    { readOnlyHint: false, destructiveHint: true },
+    async ({ path, recipe, yaml }) => {
+      if (recipe === void 0 && yaml === void 0) {
+        return err18("Provide either `recipe` (object) or `yaml` (text) to save");
+      }
+      let parsed;
+      let yamlText;
+      if (yaml !== void 0) {
+        yamlText = yaml;
+        try {
+          parsed = (0, import_yaml2.parse)(yaml);
+        } catch (e) {
+          return err18(`YAML parse error: ${e.message}`);
+        }
+      } else {
+        parsed = recipe;
+        yamlText = (0, import_yaml2.stringify)(recipe);
+      }
+      const result = validateRecipe(parsed);
+      if (!result.success) {
+        return err18("Refusing to write an invalid recipe", { errors: result.errors });
+      }
+      const absPath = (0, import_node_path.resolve)(path);
+      try {
+        (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(absPath), { recursive: true });
+        (0, import_node_fs.writeFileSync)(absPath, yamlText, "utf-8");
+      } catch (e) {
+        return err18(`Failed to write recipe: ${e.message}`);
+      }
+      return ok18({ path: absPath, warnings: result.warnings ?? [] });
+    }
+  );
+  server.tool(
+    "atelier_recipe_apply",
+    `Apply a recipe's overlay_rules to an in-store document (handle + page-number overlays). Accepts a recipe object OR a path/name. The result is stored back with source="llm". NOTE: only overlay_rules are applied here \u2014 silence-trim / transcribe / caption application remain CLI-only. page_number overlays require currentIndex + totalCount; if a recipe requests page_number without them, that layer is skipped and a warning is returned.`,
+    {
+      documentId: import_zod33.z.string().describe("In-store document ID to apply the recipe to"),
+      path: import_zod33.z.string().optional().describe("Recipe path or bare name (alternative to `recipe`)"),
+      recipe: import_zod33.z.record(import_zod33.z.unknown()).optional().describe("Recipe object (alternative to `path`)"),
+      projectDir: import_zod33.z.string().optional().describe("Project root for name resolution (default: process.cwd())"),
+      currentIndex: import_zod33.z.number().int().nonnegative().optional().describe("1-based carousel index for page_number"),
+      totalCount: import_zod33.z.number().int().positive().optional().describe("Total carousel size for page_number")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, path, recipe, projectDir, currentIndex, totalCount }) => {
+      const result = getDoc18(store, documentId);
+      if ("error" in result) return err18(result.error);
+      const { doc } = result;
+      if (path === void 0 && recipe === void 0) {
+        return err18("Provide either `path` or `recipe` to apply");
+      }
+      let resolvedRecipe;
+      if (recipe !== void 0) {
+        const validated = validateRecipe(recipe);
+        if (!validated.success) {
+          return err18("Invalid recipe", { errors: validated.errors });
+        }
+        resolvedRecipe = validated.data;
+      } else {
+        const root = (0, import_node_path.resolve)(projectDir ?? process.cwd());
+        try {
+          resolvedRecipe = loadRecipe(path, root).recipe;
+        } catch (e) {
+          return err18(e.message);
+        }
+      }
+      const { doc: updated, warnings } = applyRecipeToOverlay(doc, resolvedRecipe, {
+        currentIndex,
+        totalCount
+      });
+      store.set(documentId, updated, "llm");
+      return ok18({
+        documentId,
+        warnings,
+        layerCount: updated.layers.length,
+        document: updated
+      });
+    }
+  );
+}
+
+// ../mcp/src/tools/import-images.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+var import_zod34 = require("zod");
+function getDoc19(store, id) {
+  const doc = store.get(id);
+  if (!doc) return { error: `Document "${id}" not found` };
+  return { doc };
+}
+function ok19(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err19(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"]);
+function isImageFile(name) {
+  return IMAGE_EXTS.has((0, import_node_path2.extname)(name).toLowerCase());
+}
+function matchesGlob(name, glob) {
+  if (!glob) return true;
+  const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i").test(name);
+}
+function deriveAssetId(filename, used) {
+  const stem = (0, import_node_path2.basename)(filename, (0, import_node_path2.extname)(filename));
+  const base = stem.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "image";
+  let candidate = base;
+  let n = 2;
+  while (used.has(candidate)) {
+    candidate = `${base}-${n}`;
+    n++;
+  }
+  used.add(candidate);
+  return candidate;
+}
+function nextImageLayerId(existing, seq) {
+  let candidate = `image-${seq}`;
+  let n = seq;
+  while (existing.has(candidate)) {
+    n++;
+    candidate = `image-${n}`;
+  }
+  existing.add(candidate);
+  return candidate;
+}
+function register19(server, store) {
+  server.tool(
+    "atelier_import_images",
+    `Import every image in a folder into a document. Registers each as an asset and, unless asLayers is false, creates one fit-to-canvas ImageVisual layer per image (centered). Extensions: .png .jpg .jpeg .webp .gif .svg. Optional glob filters by filename (e.g. "*.png"); results are sorted by name. If the folder has exactly one image AND the doc's layer[0] is the welcome "background" placeholder, that image replaces the placeholder in place. Asset src is the absolute file path. Layer bounds default to a centered min(canvas.w, canvas.h) square because natural image dimensions are not measured (no image-dimension dependency).`,
+    {
+      documentId: import_zod34.z.string().describe("In-store document ID to import into"),
+      dir: import_zod34.z.string().describe("Directory containing the images"),
+      glob: import_zod34.z.string().optional().describe('Optional filename glob, e.g. "*.png" (default: all images)'),
+      asLayers: import_zod34.z.boolean().optional().describe("Create layers per image (default: true). false = register assets only.")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, dir, glob, asLayers }) => {
+      const result = getDoc19(store, documentId);
+      if ("error" in result) return err19(result.error);
+      const { doc } = result;
+      const absDir = (0, import_node_path2.resolve)(dir);
+      if (!(0, import_node_fs2.existsSync)(absDir)) return err19(`Directory "${absDir}" does not exist`);
+      if (!(0, import_node_fs2.statSync)(absDir).isDirectory()) return err19(`Path "${absDir}" is not a directory`);
+      const files = (0, import_node_fs2.readdirSync)(absDir).filter((name) => isImageFile(name) && matchesGlob(name, glob)).sort((a, b) => a.localeCompare(b));
+      if (files.length === 0) {
+        return err19(`No image files matched in "${absDir}"${glob ? ` (glob: ${glob})` : ""}`);
+      }
+      const makeLayers = asLayers !== false;
+      const canvas = doc.canvas;
+      const square = Math.min(canvas.width, canvas.height);
+      const allowBackgroundSwap = files.length === 1 && doc.layers[0]?.id === "background";
+      const newAssets = { ...doc.assets ?? {} };
+      const newLayers = [...doc.layers];
+      const usedAssetIds = new Set(Object.keys(newAssets));
+      const existingLayerIds = new Set(newLayers.map((l) => l.id));
+      const assetIds = [];
+      const layerIds = [];
+      let layerSeq = newLayers.length + 1;
+      for (const file of files) {
+        const absPath = (0, import_node_path2.join)(absDir, file);
+        const assetId = deriveAssetId(file, usedAssetIds);
+        newAssets[assetId] = { type: "image", src: absPath, description: file };
+        assetIds.push(assetId);
+        if (!makeLayers) continue;
+        const layerId = nextImageLayerId(existingLayerIds, layerSeq);
+        layerSeq++;
+        const layer = {
+          id: layerId,
+          visual: { type: "image", assetId, src: absPath },
+          frame: { x: canvas.width / 2, y: canvas.height / 2 },
+          bounds: { width: square, height: square },
+          anchorPoint: { x: 0.5, y: 0.5 },
+          opacity: 1
+        };
+        if (allowBackgroundSwap) {
+          newLayers[0] = layer;
+        } else {
+          newLayers.unshift(layer);
+        }
+        layerIds.push(layerId);
+      }
+      const newDoc = { ...doc, assets: newAssets, layers: newLayers };
+      store.set(documentId, newDoc, "llm");
+      return ok19({
+        imported: files.length,
+        assetIds,
+        layerIds,
+        asLayers: makeLayers,
+        note: "Layer bounds default to a centered square (min canvas dimension) \u2014 natural image dimensions are not measured."
+      });
+    }
+  );
+}
+
+// ../mcp/src/bridge-protocol.ts
+var BRIDGE_PROTOCOL_VERSION = 1;
+function isBridgeEnvelope(value) {
+  if (!value || typeof value !== "object") return false;
+  const t = value.type;
+  return t === "hello" || t === "doc:load" || t === "doc:loaded" || t === "doc:patch" || t === "llm:mutation" || t === "error";
+}
+
+// ../mcp/src/transports/ws-transport.ts
+var WebSocketServerTransport = class {
+  constructor(ws) {
+    this.ws = ws;
+  }
+  onclose;
+  onerror;
+  onmessage;
+  sessionId;
+  started = false;
+  closed = false;
+  async start() {
+    if (this.started) {
+      throw new Error(
+        "WebSocketServerTransport already started \u2014 the MCP SDK calls start() automatically; do not call it again"
+      );
+    }
+    this.started = true;
+    this.ws.on("message", (data) => {
+      let text;
+      try {
+        if (typeof data === "string") {
+          text = data;
+        } else if (data instanceof Buffer) {
+          text = data.toString("utf-8");
+        } else if (Array.isArray(data)) {
+          text = Buffer.concat(data).toString("utf-8");
+        } else if (data instanceof ArrayBuffer) {
+          text = Buffer.from(data).toString("utf-8");
+        } else {
+          text = String(data);
+        }
+      } catch (err20) {
+        this.onerror?.(err20 instanceof Error ? err20 : new Error(String(err20)));
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch (err20) {
+        this.onerror?.(
+          new Error(
+            `WebSocketServerTransport: failed to parse JSON-RPC message: ${err20 instanceof Error ? err20.message : String(err20)}`
+          )
+        );
+        return;
+      }
+      this.onmessage?.(parsed);
+    });
+    this.ws.on("close", () => {
+      if (this.closed) return;
+      this.closed = true;
+      this.onclose?.();
+    });
+    this.ws.on("error", (err20) => {
+      this.onerror?.(err20);
+    });
+  }
+  async send(message) {
+    if (this.closed) {
+      throw new Error("WebSocketServerTransport: cannot send after close");
+    }
+    if (this.ws.readyState !== 1) {
+      throw new Error(
+        `WebSocketServerTransport: WebSocket is not OPEN (readyState=${this.ws.readyState})`
+      );
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    try {
+      this.ws.close();
+    } catch {
+    }
+    this.onclose?.();
+  }
+};
+
 // ../mcp/src/index.ts
-function createServer() {
-  const store = new DocumentStore();
+function createServer(store = new DocumentStore()) {
   const server = new import_mcp.McpServer(
     { name: "atelier", version: "0.1.0" },
     { capabilities: { tools: {} } }
@@ -4547,6 +5418,9 @@ function createServer() {
   register14(server, store);
   register15(server, store);
   register16(server, store);
+  register17(server, store);
+  register18(server, store);
+  register19(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"));
@@ -4560,18 +5434,24 @@ if (isMain) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BRIDGE_PROTOCOL_VERSION,
   DocumentStore,
+  WebSocketServerTransport,
   createServer,
+  isBridgeEnvelope,
   registerAssetTools,
   registerDeltaTools,
   registerDocumentTools,
   registerExportTools,
+  registerImportImageTools,
   registerInteractionTools,
   registerLayerEffectTools,
   registerLayerTools,
+  registerOverlayTools,
   registerPerformanceTools,
   registerPresetTools,
   registerPreviewTools,
+  registerRecipeTools,
   registerRefTools,
   registerShapeTools,
   registerStateConfigTools,