@a-company/atelier 0.36.0 → 0.38.0

package/dist/mcp.js

@@ -86,7 +86,7 @@ var DocumentStore = class {
 };
 
 // ../mcp/src/tools/document.ts
-import { z as z16 } from "zod";
+import { z as z26 } from "zod";
 
 // ../schema/dist/index.js
 import { z } from "zod";
@@ -102,9 +102,20 @@ import { z as z10 } from "zod";
 import { z as z11 } from "zod";
 import { z as z12 } from "zod";
 import { z as z13 } from "zod";
+import { z as z17 } from "zod";
 import { z as z14 } from "zod";
 import { z as z15 } from "zod";
+import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+import { z as z19 } from "zod";
+import { z as z20 } from "zod";
+import { z as z21 } from "zod";
+import { z as z22 } from "zod";
+import { z as z23 } from "zod";
+import { parse as yamlParse2, stringify as yamlStringify2 } from "yaml";
+import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var PixelSchema = z.number();
 var PercentageSchema = z.string().regex(/^-?\d+(\.\d+)?%$/, {
   message: 'Percentage must be a number followed by %, e.g. "50%"'
@@ -357,6 +368,19 @@ var VideoVisualSchema = z8.object({
   muted: z8.boolean().optional(),
   objectFit: z8.enum(["contain", "cover", "fill"]).optional()
 });
+var AudioVisualSchema = z8.object({
+  type: z8.literal("audio"),
+  assetId: z8.string().min(1, "assetId is required"),
+  src: z8.string().optional(),
+  startFrame: z8.number().int().min(0).optional(),
+  sourceOffset: z8.number().min(0).optional(),
+  sourceEnd: z8.number().positive().optional(),
+  playbackRate: z8.number().positive().optional(),
+  volume: z8.number().min(0).max(1).optional(),
+  muted: z8.boolean().optional(),
+  fadeIn: z8.number().min(0).optional(),
+  fadeOut: z8.number().min(0).optional()
+});
 var GroupVisualSchema = z8.object({
   type: z8.literal("group")
 });
@@ -371,6 +395,7 @@ var VisualSchema = z8.discriminatedUnion("type", [
   TextVisualSchema,
   ImageVisualSchema,
   VideoVisualSchema,
+  AudioVisualSchema,
   GroupVisualSchema,
   RefVisualSchema
 ]);
@@ -452,13 +477,6 @@ var DeltaSchema = z9.object({
   description: z9.string().optional(),
   tags: z9.array(z9.string()).optional()
 });
-var AudioSchema = z10.object({
-  src: z10.string().min(1, "Audio src is required"),
-  offset: z10.number().min(0, "Audio offset must be non-negative").optional(),
-  volume: z10.number().min(0).max(1, "Audio volume must be 0\u20131").optional(),
-  loop: z10.boolean().optional(),
-  startFrame: z10.number().int().min(0, "Audio startFrame must be a non-negative integer").optional()
-});
 var StateTransitionConfigSchema = z10.object({
   duration: z10.number().int().positive("Transition duration must be a positive integer (frames)"),
   easing: EasingSchema.optional()
@@ -469,7 +487,6 @@ var StateSchema = z10.object({
   parent: z10.string().optional(),
   duration: z10.number().int().positive("State duration must be a positive integer (frames)"),
   deltas: z10.array(DeltaSchema),
-  audio: AudioSchema.optional(),
   transitions: z10.record(z10.string(), StateTransitionConfigSchema).optional()
 });
 var PresetDeltaSchema = z11.object({
@@ -509,61 +526,119 @@ var AssetSchema = z13.object({
     height: z13.number().int().positive()
   }).optional()
 });
-var CanvasSchema = z14.object({
-  width: z14.number().int().positive("Canvas width must be a positive integer"),
-  height: z14.number().int().positive("Canvas height must be a positive integer"),
-  fps: z14.number().int().positive("FPS must be a positive integer"),
-  background: z14.string().optional()
+var TimelineClipSchema = z14.object({
+  layerId: z14.string().min(1, "TimelineClip.layerId is required"),
+  startFrame: z14.number().int().min(0, "startFrame must be a non-negative integer"),
+  endFrame: z14.number().int().min(0, "endFrame must be a non-negative integer"),
+  source: z14.string().min(1, "TimelineClip.source is required")
+});
+var TimelineTrackSchema = z14.object({
+  id: z14.string().min(1, "TimelineTrack.id is required"),
+  kind: z14.enum(["video", "audio"]),
+  clips: z14.array(TimelineClipSchema)
+});
+var TimelineSchema = z14.object({
+  fps: z14.number().int().positive("Timeline.fps must be a positive integer"),
+  totalFrames: z14.number().int().min(0, "Timeline.totalFrames must be a non-negative integer"),
+  tracks: z14.array(TimelineTrackSchema)
+});
+var SlideTransitionSchema = z15.object({
+  kind: z15.enum(["cut", "crossfade", "fade"]),
+  durationFrames: z15.number().int().min(0, "transition durationFrames must be a non-negative integer").optional(),
+  color: z15.string().optional()
+});
+var SlideRefSchema = z15.object({
+  src: z15.string().min(1, "SlideRef.src is required"),
+  duration: z15.number().int().min(0, "SlideRef.duration must be a non-negative integer (frames)").optional(),
+  transition: SlideTransitionSchema.optional(),
+  label: z15.string().optional()
+});
+var DesignRelationSchema = z16.enum(["derived-from", "sibling", "references"]);
+var AtelierDesignRelationSchema = z16.object({
+  source: z16.string().min(1, "AtelierDesignRelation.source is required"),
+  relation: DesignRelationSchema,
+  note: z16.string().optional()
+});
+var DesignTypographySchema = z16.object({
+  headingFamily: z16.string().optional(),
+  bodyFamily: z16.string().optional(),
+  monoFamily: z16.string().optional(),
+  sizes: z16.record(z16.string(), z16.number().positive()).optional(),
+  weights: z16.record(z16.string(), z16.string()).optional()
+});
+var DesignMotionSchema = z16.object({
+  defaultEasing: z16.string().optional(),
+  defaultDuration: z16.number().int().positive().optional()
+});
+var AtelierDesignSchema = z16.object({
+  palette: z16.record(z16.string(), z16.string()).optional(),
+  typography: DesignTypographySchema.optional(),
+  motion: DesignMotionSchema.optional(),
+  relatedTo: z16.array(AtelierDesignRelationSchema).optional()
+});
+var CanvasSchema = z17.object({
+  width: z17.number().int().positive("Canvas width must be a positive integer"),
+  height: z17.number().int().positive("Canvas height must be a positive integer"),
+  fps: z17.number().int().positive("FPS must be a positive integer"),
+  background: z17.string().optional()
 });
-var AtelierDocumentSchema = z14.object({
-  version: z14.string().min(1, "Version is required"),
-  name: z14.string().min(1, "Animation name is required"),
-  description: z14.string().optional(),
-  tags: z14.array(z14.string()).optional(),
+var ProjectKindSchema = z17.enum(["video", "image", "carousel"]);
+var AtelierDocumentSchema = z17.object({
+  version: z17.string().min(1, "Version is required"),
+  name: z17.string().min(1, "Animation name is required"),
+  kind: ProjectKindSchema.optional(),
+  description: z17.string().optional(),
+  tags: z17.array(z17.string()).optional(),
   canvas: CanvasSchema,
-  variables: z14.record(z14.string(), VariableSchema).optional(),
-  assets: z14.record(z14.string(), AssetSchema).optional(),
-  presets: z14.record(z14.string(), PresetSchema).optional(),
-  layers: z14.array(LayerSchema),
-  states: z14.record(z14.string(), StateSchema)
+  /** Per-file design / brand block (self-contained — no auto-merge). */
+  design: AtelierDesignSchema.optional(),
+  variables: z17.record(z17.string(), VariableSchema).optional(),
+  assets: z17.record(z17.string(), AssetSchema).optional(),
+  presets: z17.record(z17.string(), PresetSchema).optional(),
+  layers: z17.array(LayerSchema),
+  states: z17.record(z17.string(), StateSchema),
+  /** Derived timeline summary for video-kind projects. Optional. */
+  timeline: TimelineSchema.optional(),
+  /** Carousel slides — only meaningful when kind === "carousel". */
+  slides: z17.array(SlideRefSchema).optional()
 });
-var SilencePolicySchema = z15.object({
-  noise: z15.string().optional(),
-  min_silence: z15.number().nonnegative().optional(),
-  default_padding_pre: z15.number().nonnegative().optional(),
-  default_padding_post: z15.number().nonnegative().optional(),
-  match_tolerance: z15.number().nonnegative().optional()
+var SilencePolicySchema = z18.object({
+  noise: z18.string().optional(),
+  min_silence: z18.number().nonnegative().optional(),
+  default_padding_pre: z18.number().nonnegative().optional(),
+  default_padding_post: z18.number().nonnegative().optional(),
+  match_tolerance: z18.number().nonnegative().optional()
 }).strict();
-var CaptionStyleSchema = z15.object({
-  font_family: z15.string().optional(),
-  font_size: z15.number().positive().optional(),
-  font_weight: z15.union([z15.literal("normal"), z15.literal("bold"), z15.number()]).optional(),
-  text_align: z15.enum(["left", "center", "right"]).optional(),
-  color: z15.string().optional(),
-  y_ratio: z15.number().min(0).max(1).optional(),
-  width_ratio: z15.number().min(0).max(1).optional(),
-  fade_seconds: z15.number().nonnegative().optional()
+var CaptionStyleSchema = z18.object({
+  font_family: z18.string().optional(),
+  font_size: z18.number().positive().optional(),
+  font_weight: z18.union([z18.literal("normal"), z18.literal("bold"), z18.number()]).optional(),
+  text_align: z18.enum(["left", "center", "right"]).optional(),
+  color: z18.string().optional(),
+  y_ratio: z18.number().min(0).max(1).optional(),
+  width_ratio: z18.number().min(0).max(1).optional(),
+  fade_seconds: z18.number().nonnegative().optional()
 }).strict();
-var CaptionGroupingSchema = z15.object({
-  max_words: z15.number().int().positive().optional(),
-  pause_gap: z15.number().nonnegative().optional()
+var CaptionGroupingSchema = z18.object({
+  max_words: z18.number().int().positive().optional(),
+  pause_gap: z18.number().nonnegative().optional()
 }).strict();
-var OverlayAnchorSchema = z15.enum([
+var OverlayAnchorSchema = z18.enum([
   "top-left",
   "top-right",
   "bottom-left",
   "bottom-right"
 ]);
-var OverlayTextStyleSchema = z15.object({
-  font_family: z15.string().optional(),
-  font_size: z15.number().positive().optional(),
-  font_weight: z15.union([z15.literal("normal"), z15.literal("bold"), z15.number()]).optional(),
-  color: z15.string().optional()
+var OverlayTextStyleSchema = z18.object({
+  font_family: z18.string().optional(),
+  font_size: z18.number().positive().optional(),
+  font_weight: z18.union([z18.literal("normal"), z18.literal("bold"), z18.number()]).optional(),
+  color: z18.string().optional()
 }).strict();
 function validatePageNumberFormat(format, ctx) {
   if (format.length === 0) {
     ctx.addIssue({
-      code: z15.ZodIssueCode.custom,
+      code: z18.ZodIssueCode.custom,
       message: "format must be a non-empty string"
     });
     return;
@@ -572,7 +647,7 @@ function validatePageNumberFormat(format, ctx) {
   const close = (format.match(/\}/g) ?? []).length;
   if (open !== close) {
     ctx.addIssue({
-      code: z15.ZodIssueCode.custom,
+      code: z18.ZodIssueCode.custom,
       message: `format has unbalanced braces (${open} '{' vs ${close} '}')`
     });
     return;
@@ -586,7 +661,7 @@ function validatePageNumberFormat(format, ctx) {
     const inner = m[1];
     if (!groupRule.test(inner)) {
       ctx.addIssue({
-        code: z15.ZodIssueCode.custom,
+        code: z18.ZodIssueCode.custom,
         message: `format placeholder "{${inner}}" is not recognized \u2014 expected {current}, {total}, {current:0Nd}, or {total:0Nd}`
       });
       return;
@@ -596,44 +671,44 @@ function validatePageNumberFormat(format, ctx) {
   }
   if (!sawCurrent && !sawTotal) {
     ctx.addIssue({
-      code: z15.ZodIssueCode.custom,
+      code: z18.ZodIssueCode.custom,
       message: "format must contain at least one {current} or {total} placeholder"
     });
   }
 }
-var OverlayHandleRuleSchema = z15.object({
-  text: z15.string().min(1),
+var OverlayHandleRuleSchema = z18.object({
+  text: z18.string().min(1),
   anchor: OverlayAnchorSchema,
-  margin: z15.number().nonnegative().optional(),
+  margin: z18.number().nonnegative().optional(),
   style: OverlayTextStyleSchema.optional()
 }).strict();
-var OverlayPageNumberRuleSchema = z15.object({
-  format: z15.string().superRefine(validatePageNumberFormat),
+var OverlayPageNumberRuleSchema = z18.object({
+  format: z18.string().superRefine(validatePageNumberFormat),
   anchor: OverlayAnchorSchema,
-  margin: z15.number().nonnegative().optional(),
+  margin: z18.number().nonnegative().optional(),
   style: OverlayTextStyleSchema.optional()
 }).strict();
-var OverlayRulesSchema = z15.object({
+var OverlayRulesSchema = z18.object({
   handle: OverlayHandleRuleSchema.optional(),
   page_number: OverlayPageNumberRuleSchema.optional()
 }).strict();
-var StudioRecipeSchema = z15.object({
-  version: z15.string(),
-  name: z15.string(),
-  description: z15.string().optional(),
-  author: z15.string().optional(),
-  tags: z15.array(z15.string()).optional(),
+var StudioRecipeSchema = z18.object({
+  version: z18.string(),
+  name: z18.string(),
+  description: z18.string().optional(),
+  author: z18.string().optional(),
+  tags: z18.array(z18.string()).optional(),
   silence_policy: SilencePolicySchema.optional(),
   caption_style: CaptionStyleSchema.optional(),
   caption_grouping: CaptionGroupingSchema.optional(),
   // Phase 1.5 — first-class overlay rules
   overlay_rules: OverlayRulesSchema.optional(),
   // Reserved — Phase 3 (parse-opaque)
-  caption_highlight: z15.unknown().optional(),
-  transition_kit: z15.unknown().optional(),
-  palette: z15.unknown().optional(),
-  audio_policy: z15.unknown().optional(),
-  aspect_targets: z15.array(z15.unknown()).optional()
+  caption_highlight: z18.unknown().optional(),
+  transition_kit: z18.unknown().optional(),
+  palette: z18.unknown().optional(),
+  audio_policy: z18.unknown().optional(),
+  aspect_targets: z18.array(z18.unknown()).optional()
 }).strict();
 var RESERVED_RECIPE_FIELDS = [
   "caption_highlight",
@@ -675,10 +750,10 @@ function parseAtelier(yamlString) {
   let parsed;
   try {
     parsed = yamlParse(yamlString);
-  } catch (err20) {
+  } catch (err24) {
     return {
       success: false,
-      errors: [{ path: "(yaml)", message: `YAML parse error: ${err20.message}` }]
+      errors: [{ path: "(yaml)", message: `YAML parse error: ${err24.message}` }]
     };
   }
   return validateDocument(parsed);
@@ -686,6 +761,290 @@ function parseAtelier(yamlString) {
 function serializeAtelier(doc) {
   return yamlStringify(doc, { indent: 2 });
 }
+var SlotKindSchema = z19.enum([
+  "image",
+  "video",
+  "audio",
+  "text",
+  "font",
+  "voice",
+  "logo"
+]);
+var SLOT_KINDS = SlotKindSchema.options;
+function parseSlotRef(ref) {
+  if (typeof ref !== "string" || ref.length === 0) return null;
+  const segments = ref.split(".");
+  if (segments.length < 2) return null;
+  if (segments.some((s) => s.length === 0)) return null;
+  const [rawKind, category, ...rest] = segments;
+  const kindParsed = SlotKindSchema.safeParse(rawKind);
+  if (!kindParsed.success) return null;
+  const specifier = rest.join(".");
+  return { kind: kindParsed.data, category, specifier };
+}
+var SlotRefSchema = z19.string().superRefine((value, ctx) => {
+  const parsed = parseSlotRef(value);
+  if (parsed !== null) return;
+  const segments = value.split(".");
+  if (segments.length < 2) {
+    ctx.addIssue({
+      code: z19.ZodIssueCode.custom,
+      message: `slot reference "${value}" must have at least two segments (<kind>.<open-tail>)`
+    });
+    return;
+  }
+  if (segments.some((s) => s.length === 0)) {
+    ctx.addIssue({
+      code: z19.ZodIssueCode.custom,
+      message: `slot reference "${value}" has an empty segment`
+    });
+    return;
+  }
+  const kindOk = SlotKindSchema.safeParse(segments[0]).success;
+  if (!kindOk) {
+    ctx.addIssue({
+      code: z19.ZodIssueCode.custom,
+      message: `slot reference "${value}" has unknown kind "${segments[0]}" \u2014 expected one of ${SLOT_KINDS.join(", ")}`
+    });
+    return;
+  }
+  ctx.addIssue({
+    code: z19.ZodIssueCode.custom,
+    message: `slot reference "${value}" is malformed`
+  });
+});
+var TechniqueLibrarySchema = z20.object({
+  version: z20.number().int().positive(),
+  techniques: z20.array(z20.string().min(1))
+}).strict();
+var DesignAudienceSchema = z21.object({
+  primary: z21.string().min(1),
+  secondary: z21.string().optional(),
+  platform: z21.array(z21.string().min(1)).min(1)
+}).strict();
+var DesignVoiceSchema = z21.object({
+  descriptors: z21.array(z21.string().min(1)).min(3).max(5),
+  references: z21.array(z21.string().min(1)).optional()
+}).strict();
+var PaletteRoleSchema = z21.enum([
+  "background",
+  "surface",
+  "primary",
+  "accent",
+  "text-on-dark",
+  "text-on-light"
+]);
+var PaletteEntrySchema = z21.object({
+  token: z21.string().min(1),
+  hex: z21.string().regex(/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/, {
+    message: "hex must be a #RGB / #RRGGBB / #RRGGBBAA string"
+  }),
+  role: PaletteRoleSchema
+}).strict();
+var TypographyUsageSchema = z21.enum(["display", "body", "caption", "mono"]);
+var TypographyEntrySchema = z21.object({
+  token: z21.string().min(1),
+  family: z21.string().min(1),
+  weights: z21.array(z21.number().int().min(1).max(1e3)).min(1),
+  usage: TypographyUsageSchema
+}).strict();
+var MotionRegisterSchema = z21.object({
+  tempo: z21.enum(["snappy", "steady", "calm", "languid"]),
+  easing_bias: z21.enum(["linear", "ease-out", "spring"]),
+  camera_bias: z21.enum(["static", "drift", "snap"]).optional()
+}).strict();
+var VisualRegisterSchema = z21.object({
+  palette: z21.array(PaletteEntrySchema).min(1),
+  typography: z21.array(TypographyEntrySchema).min(1),
+  motion_register: MotionRegisterSchema
+}).strict();
+var AspectRatioSchema = z21.enum(["9:16", "1:1", "16:9", "4:5"]);
+var DesignConstraintsSchema = z21.object({
+  max_duration_seconds: z21.number().positive().optional(),
+  aspect_ratios: z21.array(AspectRatioSchema).min(1),
+  do_not: z21.array(z21.string().min(1))
+}).strict();
+var BrandLogoSchema = z21.object({
+  token: z21.string().min(1),
+  role: z21.enum(["primary", "mark", "wordmark"])
+}).strict();
+var BrandHandleSchema = z21.object({
+  platform: z21.string().min(1),
+  value: z21.string().min(1)
+}).strict();
+var BrandReferencesSchema = z21.object({
+  logos: z21.array(BrandLogoSchema).min(1),
+  handles: z21.array(BrandHandleSchema).optional(),
+  page_number_convention: z21.string().optional()
+}).strict();
+var DesignVarianceSchema = z21.object({
+  field: z21.string().min(1),
+  value: z21.unknown(),
+  reason: z21.string().min(1)
+}).strict();
+var DesignArtifactSchema = z21.object({
+  audience: DesignAudienceSchema,
+  voice: DesignVoiceSchema,
+  visual_register: VisualRegisterSchema,
+  constraints: DesignConstraintsSchema,
+  brand_references: BrandReferencesSchema,
+  variances: z21.array(DesignVarianceSchema).optional(),
+  /** Markdown body verbatim — attached by the parser, not part of frontmatter. */
+  body: z21.string()
+}).strict();
+var BEAT_ID_RE = /^[a-z][a-z0-9-]*(\.[a-z0-9][a-z0-9-]*)*$/;
+var ScriptBeatIdSchema = z22.string().regex(BEAT_ID_RE, {
+  message: "beat id must be kebab-case (optionally dot-namespaced, e.g. `proof-1` or `b-roll.intro`)"
+});
+var NarratedBeatSchema = z22.object({
+  id: ScriptBeatIdSchema,
+  copy: z22.string().min(1),
+  intent: z22.string().min(1),
+  est_duration_s: z22.number().nonnegative(),
+  bind_to_transcript: z22.boolean().default(true)
+}).strict();
+var NonNarratedBeatSchema = z22.object({
+  id: ScriptBeatIdSchema,
+  copy: z22.string().min(1),
+  intent: z22.string().min(1),
+  est_duration_s: z22.number().nonnegative()
+}).strict();
+var NarratedBlocksSchema = z22.object({
+  hook: z22.array(NarratedBeatSchema).min(1),
+  story: z22.array(NarratedBeatSchema),
+  proof: z22.array(NarratedBeatSchema),
+  cta: z22.array(NarratedBeatSchema).min(1)
+}).strict();
+var NarratedScriptSchema = z22.object({
+  mode: z22.literal("narrated"),
+  target_duration_s: z22.number().positive(),
+  language: z22.string().min(1),
+  /** Optional slot reference for TTS voice (e.g. `voice.host.primary`). */
+  tts_voice: SlotRefSchema.optional(),
+  blocks: NarratedBlocksSchema,
+  /** Markdown body verbatim — attached by the parser when the body has stray prose. */
+  body: z22.string()
+}).strict();
+var CarouselScriptSchema = z22.object({
+  mode: z22.literal("carousel"),
+  target_duration_s: z22.number().positive(),
+  language: z22.string().min(1),
+  tts_voice: SlotRefSchema.optional(),
+  beats: z22.array(NonNarratedBeatSchema).min(1),
+  body: z22.string()
+}).strict();
+var TextOnlyScriptSchema = z22.object({
+  mode: z22.literal("text-only"),
+  target_duration_s: z22.number().positive(),
+  language: z22.string().min(1),
+  tts_voice: SlotRefSchema.optional(),
+  beats: z22.array(NonNarratedBeatSchema).min(1),
+  body: z22.string()
+}).strict();
+var ScriptArtifactSchema = z22.discriminatedUnion("mode", [
+  NarratedScriptSchema,
+  CarouselScriptSchema,
+  TextOnlyScriptSchema
+]);
+var BeatWindowSchema = z23.object({
+  start_s: z23.number().nonnegative(),
+  end_s: z23.number().nonnegative()
+}).strict().refine((w) => w.end_s > w.start_s, {
+  message: "window.end_s must be > window.start_s"
+});
+var CameraSchema = z23.object({
+  kind: z23.enum(["static", "drift", "push", "pull", "whip"]),
+  subject: z23.string().min(1).optional()
+}).strict();
+var MoodSchema = z23.string().min(1);
+var TransitionKindSchema = z23.enum(["cut", "dip-to-color", "whip", "crossfade"]);
+var TransitionOutSchema = z23.object({
+  kind: TransitionKindSchema,
+  duration_s: z23.number().nonnegative().optional(),
+  color: z23.string().min(1).optional()
+}).strict();
+var SfxEntrySchema = z23.object({
+  slot: SlotRefSchema,
+  gain_db: z23.number()
+}).strict();
+var StoryboardBeatSchema = z23.object({
+  id: ScriptBeatIdSchema,
+  window: BeatWindowSchema,
+  mood: z23.array(MoodSchema).min(1),
+  camera: CameraSchema,
+  slots: z23.array(SlotRefSchema),
+  techniques: z23.array(z23.string().min(1)),
+  transition_out: TransitionOutSchema,
+  sfx: z23.array(SfxEntrySchema).optional()
+}).strict();
+var StoryboardAspectRatioSchema = z23.enum(["9:16", "1:1", "16:9", "4:5"]);
+var StoryboardArtifactSchema = z23.object({
+  technique_library_version: z23.number().int().positive(),
+  aspect_ratio: StoryboardAspectRatioSchema,
+  beats: z23.array(StoryboardBeatSchema).min(1)
+}).strict();
+var WorkspaceManifestSchema = z24.object({
+  /** Manifest schema version. Pinned to '1.0' for the initial release. */
+  version: z24.literal("1.0"),
+  /** Display name; defaults to the workspace dir basename at create time. */
+  name: z24.string().min(1),
+  /** ISO 8601 timestamp set by the writer. */
+  created: z24.string().min(1),
+  /**
+   * Inherited by new projects created via `atelier init` inside this
+   * workspace. The creator pre-declares the autonomy posture once at the
+   * workspace level; per-project overrides still allowed via per-project
+   * `.atelier/learning-mode.yaml` (writes always happen at workspace level
+   * unless explicitly overridden).
+   */
+  default_mode: z24.enum(["ambient", "explicit"]),
+  /**
+   * Relative paths (single-segment subdir names) of known Projects inside
+   * the workspace. Advisory only — on-disk `project.atelier` presence is
+   * authoritative. Refresh via `listProjects(workspaceDir)`.
+   */
+  projects: z24.array(z24.string().min(1)).optional(),
+  /** Free-text creator description. Optional. */
+  description: z24.string().optional()
+}).strict();
+var NonEmptyStringListSchema = z25.array(z25.string().min(1));
+var MediaNotesConstraintsSchema = z25.object({
+  /**
+   * Hard exclusions. Lux + Iris MUST refuse to bind this media to a slot if
+   * any do_not rule applies (the rule is a free-text string the agent reads
+   * with judgement — e.g. "never use in a CTA beat", "no client logos").
+   */
+  do_not: NonEmptyStringListSchema.optional(),
+  /**
+   * Soft preferences — weight up candidacy when these conditions hold. Same
+   * free-text shape as do_not but the polarity is positive ("good for hooks",
+   * "prefer for warm tone").
+   */
+  prefer_for: NonEmptyStringListSchema.optional()
+}).strict();
+var MediaNotesFrontmatterSchema = z25.object({
+  /** Basename of the media file this notes file sits next to. */
+  file: z25.string().min(1),
+  /** ISO 8601 timestamp captured at ingest. */
+  added: z25.string().min(1),
+  /** User identifier (env $USER at ingest, "creator" fallback). */
+  added_by: z25.string().min(1),
+  /** Free-form labels. Empty by default; agents and creator both append. */
+  tags: NonEmptyStringListSchema.default([]),
+  /** Optional do_not / prefer_for object. Absent means "no rules yet." */
+  constraints: MediaNotesConstraintsSchema.optional()
+}).strict();
+var MediaNotesSchema = z25.object({
+  frontmatter: MediaNotesFrontmatterSchema,
+  body: z25.string()
+}).strict();
+var MediaNotesAuthorSchema = z25.enum(["lux", "quill", "iris", "creator"]);
+var MEDIA_NOTES_HEADINGS = {
+  lux: "## Lux notes (cinematographer)",
+  quill: "## Quill notes (showrunner)",
+  iris: "## Iris notes (composer)",
+  creator: "## Creator notes"
+};
 
 // ../mcp/src/tools/document.ts
 function getDoc(store, id) {
@@ -704,13 +1063,13 @@ function register(server, store) {
     "atelier_create",
     "Create a new Atelier animation document with canvas settings",
     {
-      name: z16.string().describe("Animation name"),
-      width: z16.number().positive().describe("Canvas width in pixels"),
-      height: z16.number().positive().describe("Canvas height in pixels"),
-      fps: z16.number().positive().int().describe("Frames per second"),
-      background: z16.string().optional().describe("Background color (hex string)"),
-      description: z16.string().optional().describe("Animation description"),
-      tags: z16.array(z16.string()).optional().describe("Tags for categorization")
+      name: z26.string().describe("Animation name"),
+      width: z26.number().positive().describe("Canvas width in pixels"),
+      height: z26.number().positive().describe("Canvas height in pixels"),
+      fps: z26.number().positive().int().describe("Frames per second"),
+      background: z26.string().optional().describe("Background color (hex string)"),
+      description: z26.string().optional().describe("Animation description"),
+      tags: z26.array(z26.string()).optional().describe("Tags for categorization")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ name, width, height, fps, background, description, tags }) => {
@@ -735,7 +1094,7 @@ function register(server, store) {
     "atelier_info",
     "Get summary information about an Atelier document",
     {
-      id: z16.string().describe("Document ID")
+      id: z26.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -763,8 +1122,8 @@ function register(server, store) {
     "atelier_load",
     "Load an Atelier document from a YAML string",
     {
-      id: z16.string().optional().describe("Custom document ID (auto-generated if omitted)"),
-      yaml: z16.string().describe("YAML string representing an Atelier document")
+      id: z26.string().optional().describe("Custom document ID (auto-generated if omitted)"),
+      yaml: z26.string().describe("YAML string representing an Atelier document")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, yaml }) => {
@@ -780,7 +1139,7 @@ function register(server, store) {
     "atelier_export",
     "Export an Atelier document as a YAML string",
     {
-      id: z16.string().describe("Document ID")
+      id: z26.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -803,7 +1162,7 @@ function register(server, store) {
 }
 
 // ../mcp/src/tools/layers.ts
-import { z as z17 } from "zod";
+import { z as z27 } from "zod";
 function getDoc2(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -815,69 +1174,79 @@ function ok2(data) {
 function err2(message) {
   return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
 }
-var VisualInputSchema = z17.object({
-  type: z17.enum(["shape", "text", "image", "group", "ref"]).describe("Visual type"),
+var VisualInputSchema = z27.object({
+  type: z27.enum(["shape", "text", "image", "video", "audio", "group", "ref"]).describe("Visual type"),
   // shape visual fields
-  shape: z17.object({
-    type: z17.enum(["rect", "ellipse", "path"]),
-    cornerRadius: z17.union([z17.number(), z17.tuple([z17.number(), z17.number(), z17.number(), z17.number()])]).optional(),
-    points: z17.array(z17.object({
-      x: z17.number(),
-      y: z17.number(),
-      in: z17.object({ x: z17.number(), y: z17.number() }).optional(),
-      out: z17.object({ x: z17.number(), y: z17.number() }).optional()
+  shape: z27.object({
+    type: z27.enum(["rect", "ellipse", "path"]),
+    cornerRadius: z27.union([z27.number(), z27.tuple([z27.number(), z27.number(), z27.number(), z27.number()])]).optional(),
+    points: z27.array(z27.object({
+      x: z27.number(),
+      y: z27.number(),
+      in: z27.object({ x: z27.number(), y: z27.number() }).optional(),
+      out: z27.object({ x: z27.number(), y: z27.number() }).optional()
     })).optional(),
-    closed: z17.boolean().optional()
+    closed: z27.boolean().optional()
   }).optional(),
-  fill: z17.record(z17.unknown()).optional(),
-  stroke: z17.record(z17.unknown()).optional(),
+  fill: z27.record(z27.unknown()).optional(),
+  stroke: z27.record(z27.unknown()).optional(),
   // text visual fields
-  content: z17.string().optional(),
-  style: z17.record(z17.unknown()).optional(),
+  content: z27.string().optional(),
+  style: z27.record(z27.unknown()).optional(),
   // image visual fields
-  assetId: z17.string().optional(),
-  sourceRect: z17.object({
-    x: z17.number(),
-    y: z17.number(),
-    width: z17.number().positive(),
-    height: z17.number().positive()
+  assetId: z27.string().optional(),
+  sourceRect: z27.object({
+    x: z27.number(),
+    y: z27.number(),
+    width: z27.number().positive(),
+    height: z27.number().positive()
   }).optional(),
-  spritesheet: z17.object({
-    columns: z17.number().int().positive(),
-    rows: z17.number().int().positive(),
-    frameCount: z17.number().int().positive().optional(),
-    frameWidth: z17.number().positive(),
-    frameHeight: z17.number().positive()
+  spritesheet: z27.object({
+    columns: z27.number().int().positive(),
+    rows: z27.number().int().positive(),
+    frameCount: z27.number().int().positive().optional(),
+    frameWidth: z27.number().positive(),
+    frameHeight: z27.number().positive()
   }).optional(),
-  frameIndex: z17.number().int().min(0).optional(),
+  frameIndex: z27.number().int().min(0).optional(),
   // ref visual fields
-  src: z17.string().optional(),
-  state: z17.string().optional(),
-  frame: z17.number().int().min(0).optional()
+  src: z27.string().optional(),
+  state: z27.string().optional(),
+  frame: z27.number().int().min(0).optional(),
+  // video / audio visual fields (v1.0+)
+  startFrame: z27.number().int().min(0).optional().describe("Video/audio: composition frame when playback begins"),
+  sourceOffset: z27.number().min(0).optional().describe("Video/audio: seconds into source to begin playback"),
+  sourceEnd: z27.number().positive().optional().describe("Video/audio: seconds of source to stop at"),
+  playbackRate: z27.number().positive().optional().describe("Video/audio: playback speed multiplier"),
+  volume: z27.number().min(0).max(1).optional().describe("Video/audio: volume 0\u20131"),
+  muted: z27.boolean().optional().describe("Video/audio: mute"),
+  objectFit: z27.enum(["contain", "cover", "fill"]).optional().describe("Video: fit mode"),
+  fadeIn: z27.number().min(0).optional().describe("Audio: fade-in duration in seconds"),
+  fadeOut: z27.number().min(0).optional().describe("Audio: fade-out duration in seconds")
 }).describe("Visual content definition");
 function register2(server, store) {
   server.tool(
     "atelier_add_layer",
     "Add a new layer to an Atelier document",
     {
-      id: z17.string().describe("Document ID"),
-      layerId: z17.string().describe("Unique layer ID"),
+      id: z27.string().describe("Document ID"),
+      layerId: z27.string().describe("Unique layer ID"),
       visual: VisualInputSchema.describe("Visual content definition"),
-      x: z17.union([z17.number(), z17.string()]).describe("X position (pixels or percentage)"),
-      y: z17.union([z17.number(), z17.string()]).describe("Y position (pixels or percentage)"),
-      width: z17.union([z17.number(), z17.string()]).describe("Width (pixels or percentage)"),
-      height: z17.union([z17.number(), z17.string()]).describe("Height (pixels or percentage)"),
-      description: z17.string().optional().describe("Layer description"),
-      tags: z17.array(z17.string()).optional().describe("Tags"),
-      opacity: z17.number().min(0).max(1).optional().describe("Opacity 0-1"),
-      rotation: z17.number().optional().describe("Rotation in degrees"),
-      parentId: z17.string().optional().describe("Parent layer ID for transform inheritance"),
-      anchorPoint: z17.object({ x: z17.number(), y: z17.number() }).optional().describe("Anchor point (0-1 normalized)"),
-      scale: z17.object({ x: z17.number(), y: z17.number() }).optional().describe("Scale factors"),
-      visible: z17.boolean().optional().describe("Whether layer is visible"),
-      tint: z17.object({
-        color: z17.string().describe("Tint color (hex string)"),
-        amount: z17.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
+      x: z27.union([z27.number(), z27.string()]).describe("X position (pixels or percentage)"),
+      y: z27.union([z27.number(), z27.string()]).describe("Y position (pixels or percentage)"),
+      width: z27.union([z27.number(), z27.string()]).describe("Width (pixels or percentage)"),
+      height: z27.union([z27.number(), z27.string()]).describe("Height (pixels or percentage)"),
+      description: z27.string().optional().describe("Layer description"),
+      tags: z27.array(z27.string()).optional().describe("Tags"),
+      opacity: z27.number().min(0).max(1).optional().describe("Opacity 0-1"),
+      rotation: z27.number().optional().describe("Rotation in degrees"),
+      parentId: z27.string().optional().describe("Parent layer ID for transform inheritance"),
+      anchorPoint: z27.object({ x: z27.number(), y: z27.number() }).optional().describe("Anchor point (0-1 normalized)"),
+      scale: z27.object({ x: z27.number(), y: z27.number() }).optional().describe("Scale factors"),
+      visible: z27.boolean().optional().describe("Whether layer is visible"),
+      tint: z27.object({
+        color: z27.string().describe("Tint color (hex string)"),
+        amount: z27.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
       }).optional().describe("Color tint overlay")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -914,20 +1283,20 @@ function register2(server, store) {
     "atelier_edit_layer",
     "Edit properties of an existing layer",
     {
-      id: z17.string().describe("Document ID"),
-      layerId: z17.string().describe("Layer ID to edit"),
-      x: z17.union([z17.number(), z17.string()]).optional().describe("New X position"),
-      y: z17.union([z17.number(), z17.string()]).optional().describe("New Y position"),
-      width: z17.union([z17.number(), z17.string()]).optional().describe("New width"),
-      height: z17.union([z17.number(), z17.string()]).optional().describe("New height"),
-      description: z17.string().optional().describe("New description"),
-      tags: z17.array(z17.string()).optional().describe("New tags"),
-      opacity: z17.number().min(0).max(1).optional().describe("New opacity"),
-      rotation: z17.number().optional().describe("New rotation"),
-      parentId: z17.string().nullable().optional().describe("New parent layer ID (null to clear)"),
-      anchorPoint: z17.object({ x: z17.number(), y: z17.number() }).optional().describe("New anchor point"),
-      scale: z17.object({ x: z17.number(), y: z17.number() }).optional().describe("New scale"),
-      visible: z17.boolean().optional().describe("New visibility")
+      id: z27.string().describe("Document ID"),
+      layerId: z27.string().describe("Layer ID to edit"),
+      x: z27.union([z27.number(), z27.string()]).optional().describe("New X position"),
+      y: z27.union([z27.number(), z27.string()]).optional().describe("New Y position"),
+      width: z27.union([z27.number(), z27.string()]).optional().describe("New width"),
+      height: z27.union([z27.number(), z27.string()]).optional().describe("New height"),
+      description: z27.string().optional().describe("New description"),
+      tags: z27.array(z27.string()).optional().describe("New tags"),
+      opacity: z27.number().min(0).max(1).optional().describe("New opacity"),
+      rotation: z27.number().optional().describe("New rotation"),
+      parentId: z27.string().nullable().optional().describe("New parent layer ID (null to clear)"),
+      anchorPoint: z27.object({ x: z27.number(), y: z27.number() }).optional().describe("New anchor point"),
+      scale: z27.object({ x: z27.number(), y: z27.number() }).optional().describe("New scale"),
+      visible: z27.boolean().optional().describe("New visibility")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, x, y, width, height, description, tags, opacity, rotation, parentId, anchorPoint, scale, visible }) => {
@@ -962,8 +1331,8 @@ function register2(server, store) {
     "atelier_remove_layer",
     "Remove a layer from an Atelier document",
     {
-      id: z17.string().describe("Document ID"),
-      layerId: z17.string().describe("Layer ID to remove")
+      id: z27.string().describe("Document ID"),
+      layerId: z27.string().describe("Layer ID to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, layerId }) => {
@@ -991,7 +1360,7 @@ function register2(server, store) {
     "atelier_list_layers",
     "List all layers in an Atelier document",
     {
-      id: z17.string().describe("Document ID")
+      id: z27.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -1018,9 +1387,9 @@ function register2(server, store) {
     "atelier_reorder",
     "Move a layer to a new position in the layer stack",
     {
-      id: z17.string().describe("Document ID"),
-      layerId: z17.string().describe("Layer ID to move"),
-      position: z17.number().int().min(0).describe("Target position index (0-based)")
+      id: z27.string().describe("Document ID"),
+      layerId: z27.string().describe("Layer ID to move"),
+      position: z27.number().int().min(0).describe("Target position index (0-based)")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, position }) => {
@@ -1038,7 +1407,7 @@ function register2(server, store) {
 }
 
 // ../mcp/src/tools/shapes.ts
-import { z as z18 } from "zod";
+import { z as z28 } from "zod";
 function getDoc3(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -1055,21 +1424,21 @@ function register3(server, store) {
     "atelier_set_shape",
     "Set the shape on a shape-type layer",
     {
-      id: z18.string().describe("Document ID"),
-      layerId: z18.string().describe("Layer ID (must be a shape visual)"),
-      shape: z18.object({
-        type: z18.enum(["rect", "ellipse", "path"]).describe("Shape type"),
-        cornerRadius: z18.union([
-          z18.number(),
-          z18.tuple([z18.number(), z18.number(), z18.number(), z18.number()])
+      id: z28.string().describe("Document ID"),
+      layerId: z28.string().describe("Layer ID (must be a shape visual)"),
+      shape: z28.object({
+        type: z28.enum(["rect", "ellipse", "path"]).describe("Shape type"),
+        cornerRadius: z28.union([
+          z28.number(),
+          z28.tuple([z28.number(), z28.number(), z28.number(), z28.number()])
         ]).optional().describe("Corner radius (rect only)"),
-        points: z18.array(z18.object({
-          x: z18.number(),
-          y: z18.number(),
-          in: z18.object({ x: z18.number(), y: z18.number() }).optional(),
-          out: z18.object({ x: z18.number(), y: z18.number() }).optional()
+        points: z28.array(z28.object({
+          x: z28.number(),
+          y: z28.number(),
+          in: z28.object({ x: z28.number(), y: z28.number() }).optional(),
+          out: z28.object({ x: z28.number(), y: z28.number() }).optional()
         })).optional().describe("Path points (path only)"),
-        closed: z18.boolean().optional().describe("Whether path is closed (path only)")
+        closed: z28.boolean().optional().describe("Whether path is closed (path only)")
       }).describe("Shape definition")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -1088,20 +1457,20 @@ function register3(server, store) {
     "atelier_set_fill",
     "Set the fill on a shape-type layer",
     {
-      id: z18.string().describe("Document ID"),
-      layerId: z18.string().describe("Layer ID (must be a shape visual)"),
-      fill: z18.object({
-        type: z18.enum(["solid", "linear-gradient", "radial-gradient"]).describe("Fill type"),
-        color: z18.unknown().optional().describe("Color for solid fill (hex string or RGBA/HSLA object)"),
-        angle: z18.number().optional().describe("Angle in degrees (linear-gradient only)"),
-        center: z18.object({
-          x: z18.union([z18.number(), z18.string()]),
-          y: z18.union([z18.number(), z18.string()])
+      id: z28.string().describe("Document ID"),
+      layerId: z28.string().describe("Layer ID (must be a shape visual)"),
+      fill: z28.object({
+        type: z28.enum(["solid", "linear-gradient", "radial-gradient"]).describe("Fill type"),
+        color: z28.unknown().optional().describe("Color for solid fill (hex string or RGBA/HSLA object)"),
+        angle: z28.number().optional().describe("Angle in degrees (linear-gradient only)"),
+        center: z28.object({
+          x: z28.union([z28.number(), z28.string()]),
+          y: z28.union([z28.number(), z28.string()])
         }).optional().describe("Center point (radial-gradient only)"),
-        radius: z18.union([z18.number(), z18.string()]).optional().describe("Radius (radial-gradient only)"),
-        stops: z18.array(z18.object({
-          offset: z18.number().min(0).max(1),
-          color: z18.unknown()
+        radius: z28.union([z28.number(), z28.string()]).optional().describe("Radius (radial-gradient only)"),
+        stops: z28.array(z28.object({
+          offset: z28.number().min(0).max(1),
+          color: z28.unknown()
         })).optional().describe("Gradient stops")
       }).describe("Fill definition")
     },
@@ -1121,14 +1490,14 @@ function register3(server, store) {
     "atelier_set_stroke",
     "Set the stroke on a shape-type layer",
     {
-      id: z18.string().describe("Document ID"),
-      layerId: z18.string().describe("Layer ID (must be a shape visual)"),
-      stroke: z18.object({
-        color: z18.unknown().describe("Stroke color (hex string or RGBA/HSLA object)"),
-        width: z18.number().positive().describe("Stroke width in pixels"),
-        dash: z18.array(z18.number()).optional().describe("Dash pattern"),
-        lineCap: z18.enum(["butt", "round", "square"]).optional().describe("Line cap style"),
-        lineJoin: z18.enum(["miter", "round", "bevel"]).optional().describe("Line join style")
+      id: z28.string().describe("Document ID"),
+      layerId: z28.string().describe("Layer ID (must be a shape visual)"),
+      stroke: z28.object({
+        color: z28.unknown().describe("Stroke color (hex string or RGBA/HSLA object)"),
+        width: z28.number().positive().describe("Stroke width in pixels"),
+        dash: z28.array(z28.number()).optional().describe("Dash pattern"),
+        lineCap: z28.enum(["butt", "round", "square"]).optional().describe("Line cap style"),
+        lineJoin: z28.enum(["miter", "round", "bevel"]).optional().describe("Line join style")
       }).describe("Stroke definition")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -1146,7 +1515,7 @@ function register3(server, store) {
 }
 
 // ../mcp/src/tools/states.ts
-import { z as z19 } from "zod";
+import { z as z29 } from "zod";
 function getDoc4(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -1163,11 +1532,11 @@ function register4(server, store) {
     "atelier_add_state",
     "Add a named animation state to a document",
     {
-      id: z19.string().describe("Document ID"),
-      stateName: z19.string().describe("State name (e.g. 'intro', 'hover', 'exit')"),
-      duration: z19.number().positive().int().describe("Duration in frames"),
-      description: z19.string().optional().describe("State description"),
-      tags: z19.array(z19.string()).optional().describe("Tags")
+      id: z29.string().describe("Document ID"),
+      stateName: z29.string().describe("State name (e.g. 'intro', 'hover', 'exit')"),
+      duration: z29.number().positive().int().describe("Duration in frames"),
+      description: z29.string().optional().describe("State description"),
+      tags: z29.array(z29.string()).optional().describe("Tags")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, duration, description, tags }) => {
@@ -1190,11 +1559,11 @@ function register4(server, store) {
     "atelier_edit_state",
     "Edit metadata of an existing animation state",
     {
-      id: z19.string().describe("Document ID"),
-      stateName: z19.string().describe("State name to edit"),
-      duration: z19.number().positive().int().optional().describe("New duration in frames"),
-      description: z19.string().optional().describe("New description"),
-      tags: z19.array(z19.string()).optional().describe("New tags")
+      id: z29.string().describe("Document ID"),
+      stateName: z29.string().describe("State name to edit"),
+      duration: z29.number().positive().int().optional().describe("New duration in frames"),
+      description: z29.string().optional().describe("New description"),
+      tags: z29.array(z29.string()).optional().describe("New tags")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, duration, description, tags }) => {
@@ -1213,8 +1582,8 @@ function register4(server, store) {
     "atelier_remove_state",
     "Remove an animation state and all its deltas",
     {
-      id: z19.string().describe("Document ID"),
-      stateName: z19.string().describe("State name to remove")
+      id: z29.string().describe("Document ID"),
+      stateName: z29.string().describe("State name to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, stateName }) => {
@@ -1231,7 +1600,7 @@ function register4(server, store) {
     "atelier_list_states",
     "List all animation states in a document",
     {
-      id: z19.string().describe("Document ID")
+      id: z29.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -1251,7 +1620,7 @@ function register4(server, store) {
 }
 
 // ../mcp/src/tools/deltas.ts
-import { z as z20 } from "zod";
+import { z as z30 } from "zod";
 
 // ../math/dist/index.js
 function linear(t) {
@@ -1796,12 +2165,15 @@ function resolveFrame(doc, stateName, frame, overrideDeltas) {
     throw new Error(`State "${stateName}" not found in document "${doc.name}"`);
   }
   const deltasByLayerProperty = groupDeltas(overrideDeltas ?? state.deltas);
+  const ancestorClipStartFrame = computeAncestorClipStartFrames(doc);
   const resolvedLayers = doc.layers.map((layer) => {
     const computedProperties = {};
     const layerDeltas = deltasByLayerProperty.get(layer.id);
     if (layerDeltas) {
+      const offset = ancestorClipStartFrame.get(layer.id) ?? 0;
+      const localFrame = frame - offset;
       for (const [property, deltas] of layerDeltas) {
-        const value = resolvePropertyAtFrame(deltas, frame);
+        const value = resolvePropertyAtFrame(deltas, localFrame);
         if (value !== void 0) {
           computedProperties[property] = value;
         }
@@ -1822,6 +2194,26 @@ function resolveFrame(doc, stateName, frame, overrideDeltas) {
   });
   return { frame, stateName, layers: resolvedLayers };
 }
+function computeAncestorClipStartFrames(doc) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const l of doc.layers) byId.set(l.id, l);
+  const result = /* @__PURE__ */ new Map();
+  for (const layer of doc.layers) {
+    let cursor = byId.get(layer.parentId ?? "");
+    const visited = /* @__PURE__ */ new Set();
+    while (cursor) {
+      if (visited.has(cursor.id)) break;
+      visited.add(cursor.id);
+      if (cursor.visual.type === "video") {
+        const v = cursor.visual;
+        result.set(layer.id, v.startFrame ?? 0);
+        break;
+      }
+      cursor = byId.get(cursor.parentId ?? "");
+    }
+  }
+  return result;
+}
 function groupDeltas(deltas) {
   const map = /* @__PURE__ */ new Map();
   for (const delta of deltas) {
@@ -1990,17 +2382,17 @@ function register5(server, store) {
     "atelier_add_delta",
     "Add an animation delta (keyframe transition) to a state",
     {
-      id: z20.string().describe("Document ID"),
-      stateName: z20.string().describe("State name"),
-      layer: z20.string().describe("Target layer ID"),
+      id: z30.string().describe("Document ID"),
+      stateName: z30.string().describe("State name"),
+      layer: z30.string().describe("Target layer ID"),
       property: AnimatablePropertyEnum.describe("Property to animate"),
-      range: z20.tuple([z20.number().int().min(0), z20.number().int().min(0)]).describe("Frame range [start, end] inclusive"),
-      from: z20.unknown().describe("Starting value"),
-      to: z20.unknown().describe("Ending value"),
+      range: z30.tuple([z30.number().int().min(0), z30.number().int().min(0)]).describe("Frame range [start, end] inclusive"),
+      from: z30.unknown().describe("Starting value"),
+      to: z30.unknown().describe("Ending value"),
       easing: EasingInputSchema.optional().describe("Easing function"),
-      description: z20.string().optional().describe("Delta description"),
-      tags: z20.array(z20.string()).optional().describe("Tags"),
-      deltaId: z20.string().optional().describe("Custom delta ID")
+      description: z30.string().optional().describe("Delta description"),
+      tags: z30.array(z30.string()).optional().describe("Tags"),
+      deltaId: z30.string().optional().describe("Custom delta ID")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, layer, property, range, from, to, easing, description, tags, deltaId }) => {
@@ -2038,17 +2430,17 @@ function register5(server, store) {
     "atelier_edit_delta",
     "Edit an existing delta by index within a state",
     {
-      id: z20.string().describe("Document ID"),
-      stateName: z20.string().describe("State name"),
-      deltaIndex: z20.number().int().min(0).describe("Delta index within the state"),
-      layer: z20.string().optional().describe("New target layer ID"),
+      id: z30.string().describe("Document ID"),
+      stateName: z30.string().describe("State name"),
+      deltaIndex: z30.number().int().min(0).describe("Delta index within the state"),
+      layer: z30.string().optional().describe("New target layer ID"),
       property: AnimatablePropertyEnum.optional().describe("New property to animate"),
-      range: z20.tuple([z20.number().int().min(0), z20.number().int().min(0)]).optional().describe("New frame range [start, end]"),
-      from: z20.unknown().optional().describe("New starting value"),
-      to: z20.unknown().optional().describe("New ending value"),
+      range: z30.tuple([z30.number().int().min(0), z30.number().int().min(0)]).optional().describe("New frame range [start, end]"),
+      from: z30.unknown().optional().describe("New starting value"),
+      to: z30.unknown().optional().describe("New ending value"),
       easing: EasingInputSchema.optional().describe("New easing function"),
-      description: z20.string().optional().describe("New description"),
-      tags: z20.array(z20.string()).optional().describe("New tags")
+      description: z30.string().optional().describe("New description"),
+      tags: z30.array(z30.string()).optional().describe("New tags")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, deltaIndex, layer, property, range, from, to, easing, description, tags }) => {
@@ -2087,9 +2479,9 @@ function register5(server, store) {
     "atelier_remove_delta",
     "Remove a delta by index from a state",
     {
-      id: z20.string().describe("Document ID"),
-      stateName: z20.string().describe("State name"),
-      deltaIndex: z20.number().int().min(0).describe("Delta index to remove")
+      id: z30.string().describe("Document ID"),
+      stateName: z30.string().describe("State name"),
+      deltaIndex: z30.number().int().min(0).describe("Delta index to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, stateName, deltaIndex }) => {
@@ -2117,12 +2509,12 @@ function register5(server, store) {
     "atelier_apply_preset",
     "Apply a preset to a layer, expanding it into concrete deltas",
     {
-      id: z20.string().describe("Document ID"),
-      stateName: z20.string().describe("State name to add deltas to"),
-      presetName: z20.string().describe("Preset name defined in the document"),
-      layerId: z20.string().describe("Target layer ID"),
-      startFrame: z20.number().int().min(0).optional().describe("Start frame (default: 0)"),
-      duration: z20.number().positive().int().optional().describe("Duration for preset (default: state duration)")
+      id: z30.string().describe("Document ID"),
+      stateName: z30.string().describe("State name to add deltas to"),
+      presetName: z30.string().describe("Preset name defined in the document"),
+      layerId: z30.string().describe("Target layer ID"),
+      startFrame: z30.number().int().min(0).optional().describe("Start frame (default: 0)"),
+      duration: z30.number().positive().int().optional().describe("Duration for preset (default: state duration)")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, presetName, layerId, startFrame, duration }) => {
@@ -2165,7 +2557,7 @@ ${errors.join("\n")}`);
 }
 
 // ../mcp/src/tools/presets.ts
-import { z as z21 } from "zod";
+import { z as z31 } from "zod";
 function getDoc6(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2179,11 +2571,11 @@ function err6(message) {
 }
 var AnimatablePropertyEnum2 = AnimatablePropertySchema;
 var EasingInputSchema2 = EasingSchema;
-var PresetDeltaSchema2 = z21.object({
+var PresetDeltaSchema2 = z31.object({
   property: AnimatablePropertyEnum2.describe("Animatable property"),
-  offset: z21.tuple([z21.number().int().min(0), z21.number().int().min(0)]).optional().describe("Relative frame offset [start, end]"),
-  from: z21.unknown().describe("Starting value"),
-  to: z21.unknown().describe("Ending value"),
+  offset: z31.tuple([z31.number().int().min(0), z31.number().int().min(0)]).optional().describe("Relative frame offset [start, end]"),
+  from: z31.unknown().describe("Starting value"),
+  to: z31.unknown().describe("Ending value"),
   easing: EasingInputSchema2.optional().describe("Easing function")
 });
 function register6(server, store) {
@@ -2191,11 +2583,11 @@ function register6(server, store) {
     "atelier_define_preset",
     "Define a reusable animation preset on a document",
     {
-      id: z21.string().describe("Document ID"),
-      presetName: z21.string().describe("Preset name"),
-      description: z21.string().optional().describe("Preset description"),
-      tags: z21.array(z21.string()).optional().describe("Tags"),
-      deltas: z21.array(PresetDeltaSchema2).min(1).describe("Array of preset delta definitions")
+      id: z31.string().describe("Document ID"),
+      presetName: z31.string().describe("Preset name"),
+      description: z31.string().optional().describe("Preset description"),
+      tags: z31.array(z31.string()).optional().describe("Tags"),
+      deltas: z31.array(PresetDeltaSchema2).min(1).describe("Array of preset delta definitions")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, presetName, description, tags, deltas }) => {
@@ -2216,7 +2608,7 @@ function register6(server, store) {
     "atelier_list_presets",
     "List all presets defined on a document",
     {
-      id: z21.string().describe("Document ID")
+      id: z31.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -2239,7 +2631,7 @@ function register6(server, store) {
 }
 
 // ../mcp/src/tools/preview.ts
-import { z as z22 } from "zod";
+import { z as z32 } from "zod";
 function getDoc7(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2256,7 +2648,7 @@ function register7(server, store) {
     "atelier_validate",
     "Validate an Atelier document for schema correctness and delta overlaps",
     {
-      id: z22.string().describe("Document ID")
+      id: z32.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -2285,9 +2677,9 @@ function register7(server, store) {
     "atelier_preview",
     "Preview the resolved state of all layers at a specific frame",
     {
-      id: z22.string().describe("Document ID"),
-      stateName: z22.string().describe("State name to preview"),
-      frame: z22.number().int().min(0).describe("Frame number to resolve")
+      id: z32.string().describe("Document ID"),
+      stateName: z32.string().describe("State name to preview"),
+      frame: z32.number().int().min(0).describe("Frame number to resolve")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frame }) => {
@@ -2322,7 +2714,7 @@ function register7(server, store) {
 }
 
 // ../mcp/src/tools/templates.ts
-import { z as z23 } from "zod";
+import { z as z33 } from "zod";
 function getDoc8(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2339,8 +2731,8 @@ function register8(server, store) {
     "atelier_instantiate_template",
     "Instantiate a template document with variable bindings. Creates a new document in the store.",
     {
-      id: z23.string().describe("Template document ID"),
-      bindings: z23.record(z23.unknown()).describe("Variable bindings: { variableName: value }")
+      id: z33.string().describe("Template document ID"),
+      bindings: z33.record(z33.unknown()).describe("Variable bindings: { variableName: value }")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, bindings }) => {
@@ -2363,7 +2755,7 @@ function register8(server, store) {
     "atelier_find_variables",
     "Scan a document for {{variableName}} patterns. Returns the list of variable references found.",
     {
-      id: z23.string().describe("Document ID")
+      id: z33.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -2383,7 +2775,7 @@ function register8(server, store) {
 }
 
 // ../mcp/src/tools/layer-effects.ts
-import { z as z24 } from "zod";
+import { z as z34 } from "zod";
 function getDoc9(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2400,9 +2792,9 @@ function register9(server, store) {
     "atelier_set_blend_mode",
     "Set or clear the blend mode on a layer",
     {
-      id: z24.string().describe("Document ID"),
-      layerId: z24.string().describe("Layer ID"),
-      blendMode: z24.enum([
+      id: z34.string().describe("Document ID"),
+      layerId: z34.string().describe("Layer ID"),
+      blendMode: z34.enum([
         "normal",
         "multiply",
         "screen",
@@ -2440,13 +2832,13 @@ function register9(server, store) {
     "atelier_set_shadow",
     "Set or remove a drop shadow on a layer",
     {
-      id: z24.string().describe("Document ID"),
-      layerId: z24.string().describe("Layer ID"),
-      shadow: z24.object({
-        color: z24.unknown().describe("Shadow color (hex string or RGBA/HSLA object)"),
-        blur: z24.number().min(0).describe("Blur radius in pixels"),
-        offsetX: z24.number().optional().describe("Horizontal offset in pixels"),
-        offsetY: z24.number().optional().describe("Vertical offset in pixels")
+      id: z34.string().describe("Document ID"),
+      layerId: z34.string().describe("Layer ID"),
+      shadow: z34.object({
+        color: z34.unknown().describe("Shadow color (hex string or RGBA/HSLA object)"),
+        blur: z34.number().min(0).describe("Blur radius in pixels"),
+        offsetX: z34.number().optional().describe("Horizontal offset in pixels"),
+        offsetY: z34.number().optional().describe("Vertical offset in pixels")
       }).nullable().describe("Shadow definition, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2468,11 +2860,11 @@ function register9(server, store) {
     "atelier_set_tint",
     "Set or remove a color tint on a layer (works on any visual type)",
     {
-      id: z24.string().describe("Document ID"),
-      layerId: z24.string().describe("Layer ID"),
-      tint: z24.object({
-        color: z24.string().describe("Tint color (hex string)"),
-        amount: z24.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
+      id: z34.string().describe("Document ID"),
+      layerId: z34.string().describe("Layer ID"),
+      tint: z34.object({
+        color: z34.string().describe("Tint color (hex string)"),
+        amount: z34.number().min(0).max(1).describe("Tint amount (0 = none, 1 = full)")
       }).nullable().describe("Tint definition, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2494,18 +2886,18 @@ function register9(server, store) {
     "atelier_set_motion_path",
     "Set or remove a motion path on a layer for path-based position animation",
     {
-      id: z24.string().describe("Document ID"),
-      layerId: z24.string().describe("Layer ID"),
-      motionPath: z24.object({
-        points: z24.array(z24.object({
-          x: z24.number(),
-          y: z24.number(),
-          in: z24.object({ x: z24.number(), y: z24.number() }).optional(),
-          out: z24.object({ x: z24.number(), y: z24.number() }).optional()
+      id: z34.string().describe("Document ID"),
+      layerId: z34.string().describe("Layer ID"),
+      motionPath: z34.object({
+        points: z34.array(z34.object({
+          x: z34.number(),
+          y: z34.number(),
+          in: z34.object({ x: z34.number(), y: z34.number() }).optional(),
+          out: z34.object({ x: z34.number(), y: z34.number() }).optional()
         })).min(2).describe("Path points (minimum 2)"),
-        closed: z24.boolean().optional().describe("Whether the path is closed"),
-        autoRotate: z24.boolean().optional().describe("Auto-rotate layer to follow path tangent"),
-        autoRotateOffset: z24.number().optional().describe("Rotation offset in degrees when autoRotate is enabled")
+        closed: z34.boolean().optional().describe("Whether the path is closed"),
+        autoRotate: z34.boolean().optional().describe("Auto-rotate layer to follow path tangent"),
+        autoRotateOffset: z34.number().optional().describe("Rotation offset in degrees when autoRotate is enabled")
       }).nullable().describe("Motion path definition, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2527,21 +2919,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: z24.string().describe("Document ID"),
-      layerId: z24.string().describe("Layer ID"),
-      clipPath: z24.object({
-        type: z24.enum(["rect", "ellipse", "path"]).describe("Clip shape type"),
-        cornerRadius: z24.union([
-          z24.number(),
-          z24.tuple([z24.number(), z24.number(), z24.number(), z24.number()])
+      id: z34.string().describe("Document ID"),
+      layerId: z34.string().describe("Layer ID"),
+      clipPath: z34.object({
+        type: z34.enum(["rect", "ellipse", "path"]).describe("Clip shape type"),
+        cornerRadius: z34.union([
+          z34.number(),
+          z34.tuple([z34.number(), z34.number(), z34.number(), z34.number()])
         ]).optional().describe("Corner radius (rect only)"),
-        points: z24.array(z24.object({
-          x: z24.number(),
-          y: z24.number(),
-          in: z24.object({ x: z24.number(), y: z24.number() }).optional(),
-          out: z24.object({ x: z24.number(), y: z24.number() }).optional()
+        points: z34.array(z34.object({
+          x: z34.number(),
+          y: z34.number(),
+          in: z34.object({ x: z34.number(), y: z34.number() }).optional(),
+          out: z34.object({ x: z34.number(), y: z34.number() }).optional()
         })).optional().describe("Path points (path only)"),
-        closed: z24.boolean().optional().describe("Whether path is closed (path only)")
+        closed: z34.boolean().optional().describe("Whether path is closed (path only)")
       }).nullable().describe("Clip path shape, or null to remove")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -2563,45 +2955,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: z24.string().describe("Document ID"),
-      layerId: z24.string().describe("Layer ID"),
+      id: z34.string().describe("Document ID"),
+      layerId: z34.string().describe("Layer ID"),
       // Text fields
-      content: z24.string().optional().describe("New text content (text layers only)"),
-      style: z24.record(z24.unknown()).optional().describe("Partial style update \u2014 only provided keys are overwritten (text layers only)"),
+      content: z34.string().optional().describe("New text content (text layers only)"),
+      style: z34.record(z34.unknown()).optional().describe("Partial style update \u2014 only provided keys are overwritten (text layers only)"),
       // Image fields
-      src: z24.string().optional().describe("Image source URL (image layers only)"),
-      assetId: z24.string().optional().describe("Asset ID reference (image layers only)"),
-      sourceRect: z24.object({
-        x: z24.number(),
-        y: z24.number(),
-        width: z24.number().positive(),
-        height: z24.number().positive()
+      src: z34.string().optional().describe("Image source URL (image layers only)"),
+      assetId: z34.string().optional().describe("Asset ID reference (image layers only)"),
+      sourceRect: z34.object({
+        x: z34.number(),
+        y: z34.number(),
+        width: z34.number().positive(),
+        height: z34.number().positive()
       }).nullable().optional().describe("Source rectangle crop (image layers only). Null to remove."),
-      spritesheet: z24.object({
-        columns: z24.number().int().positive(),
-        rows: z24.number().int().positive(),
-        frameCount: z24.number().int().positive().optional(),
-        frameWidth: z24.number().positive(),
-        frameHeight: z24.number().positive()
+      spritesheet: z34.object({
+        columns: z34.number().int().positive(),
+        rows: z34.number().int().positive(),
+        frameCount: z34.number().int().positive().optional(),
+        frameWidth: z34.number().positive(),
+        frameHeight: z34.number().positive()
       }).nullable().optional().describe("Spritesheet config (image layers only). Null to remove."),
-      frameIndex: z24.number().int().min(0).optional().describe("Spritesheet frame index (image layers only)"),
+      frameIndex: z34.number().int().min(0).optional().describe("Spritesheet frame index (image layers only)"),
       // Shape fields
-      shape: z24.object({
-        type: z24.enum(["rect", "ellipse", "path"]),
-        cornerRadius: z24.union([
-          z24.number(),
-          z24.tuple([z24.number(), z24.number(), z24.number(), z24.number()])
+      shape: z34.object({
+        type: z34.enum(["rect", "ellipse", "path"]),
+        cornerRadius: z34.union([
+          z34.number(),
+          z34.tuple([z34.number(), z34.number(), z34.number(), z34.number()])
         ]).optional(),
-        points: z24.array(z24.object({
-          x: z24.number(),
-          y: z24.number(),
-          in: z24.object({ x: z24.number(), y: z24.number() }).optional(),
-          out: z24.object({ x: z24.number(), y: z24.number() }).optional()
+        points: z34.array(z34.object({
+          x: z34.number(),
+          y: z34.number(),
+          in: z34.object({ x: z34.number(), y: z34.number() }).optional(),
+          out: z34.object({ x: z34.number(), y: z34.number() }).optional()
         })).optional(),
-        closed: z24.boolean().optional()
+        closed: z34.boolean().optional()
       }).optional().describe("New shape (shape layers only)"),
-      fill: z24.record(z24.unknown()).optional().describe("New fill definition (shape layers only)"),
-      stroke: z24.record(z24.unknown()).optional().describe("New stroke definition (shape layers only)")
+      fill: z34.record(z34.unknown()).optional().describe("New fill definition (shape layers only)"),
+      stroke: z34.record(z34.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 }) => {
@@ -2682,7 +3074,7 @@ function register9(server, store) {
 }
 
 // ../mcp/src/tools/state-config.ts
-import { z as z25 } from "zod";
+import { z as z35 } from "zod";
 function getDoc10(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -2694,68 +3086,39 @@ function ok10(data) {
 function err10(message) {
   return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
 }
-var EasingInputSchema3 = z25.union([
-  z25.enum(["ease-in", "ease-out", "ease-in-out"]),
-  z25.object({ type: z25.literal("linear") }),
-  z25.object({
-    type: z25.literal("cubic-bezier"),
-    x1: z25.number(),
-    y1: z25.number(),
-    x2: z25.number(),
-    y2: z25.number()
+var EasingInputSchema3 = z35.union([
+  z35.enum(["ease-in", "ease-out", "ease-in-out"]),
+  z35.object({ type: z35.literal("linear") }),
+  z35.object({
+    type: z35.literal("cubic-bezier"),
+    x1: z35.number(),
+    y1: z35.number(),
+    x2: z35.number(),
+    y2: z35.number()
   }),
-  z25.object({
-    type: z25.literal("spring"),
-    mass: z25.number().optional(),
-    stiffness: z25.number().optional(),
-    damping: z25.number().optional(),
-    velocity: z25.number().optional()
+  z35.object({
+    type: z35.literal("spring"),
+    mass: z35.number().optional(),
+    stiffness: z35.number().optional(),
+    damping: z35.number().optional(),
+    velocity: z35.number().optional()
   }),
-  z25.object({
-    type: z25.literal("step"),
-    steps: z25.number().int().positive(),
-    position: z25.enum(["start", "end"]).optional()
+  z35.object({
+    type: z35.literal("step"),
+    steps: z35.number().int().positive(),
+    position: z35.enum(["start", "end"]).optional()
   })
 ]).describe("Easing function");
 function register10(server, store) {
-  server.tool(
-    "atelier_set_audio",
-    "Set or remove an audio track on a state",
-    {
-      id: z25.string().describe("Document ID"),
-      stateName: z25.string().describe("State name"),
-      audio: z25.object({
-        src: z25.string().describe("Audio source \u2014 asset reference, file path, or URL"),
-        offset: z25.number().min(0).optional().describe("Skip into audio in seconds (default: 0)"),
-        volume: z25.number().min(0).max(1).optional().describe("Playback volume 0\u20131 (default: 1)"),
-        loop: z25.boolean().optional().describe("Loop for state duration (default: false)"),
-        startFrame: z25.number().int().min(0).optional().describe("Frame to start playing (default: 0)")
-      }).nullable().describe("Audio configuration, or null to remove")
-    },
-    { readOnlyHint: false, destructiveHint: false },
-    async ({ id, stateName, audio }) => {
-      const result = getDoc10(store, id);
-      if ("error" in result) return err10(result.error);
-      const { doc } = result;
-      const state = doc.states[stateName];
-      if (!state) return err10(`State "${stateName}" not found`);
-      if (audio === null) {
-        delete state.audio;
-        return ok10({ stateName, audio: null, removed: true });
-      }
-      state.audio = audio;
-      return ok10({ stateName, audioSrc: audio.src });
-    }
-  );
   server.tool(
     "atelier_configure_transition",
     "Configure or remove a transition from one state to a target state",
     {
-      id: z25.string().describe("Document ID"),
-      stateName: z25.string().describe("Source state name"),
-      targetState: z25.string().describe("Target state name"),
-      transition: z25.object({
-        duration: z25.number().positive().int().describe("Transition duration in frames"),
+      id: z35.string().describe("Document ID"),
+      stateName: z35.string().describe("Source state name"),
+      targetState: z35.string().describe("Target state name"),
+      transition: z35.object({
+        duration: z35.number().positive().int().describe("Transition duration in frames"),
         easing: EasingInputSchema3.optional()
       }).nullable().describe("Transition config, or null to remove")
     },
@@ -2792,9 +3155,9 @@ function register10(server, store) {
     "atelier_set_state_parent",
     "Set or clear the parent state for hierarchical delta inheritance",
     {
-      id: z25.string().describe("Document ID"),
-      stateName: z25.string().describe("State name"),
-      parent: z25.string().nullable().describe("Parent state name, or null to clear")
+      id: z35.string().describe("Document ID"),
+      stateName: z35.string().describe("State name"),
+      parent: z35.string().nullable().describe("Parent state name, or null to clear")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, stateName, parent }) => {
@@ -2829,7 +3192,7 @@ function register10(server, store) {
 }
 
 // ../mcp/src/tools/export.ts
-import { z as z26 } from "zod";
+import { z as z36 } from "zod";
 
 // ../canvas/dist/index.js
 function colorToCSS(color) {
@@ -3924,8 +4287,11 @@ function mapBlendMode(mode) {
 }
 function collectUnsupportedWarnings(doc, state) {
   const warnings = [];
-  if (state.audio) {
-    warnings.push("Audio tracks are not supported in Lottie format and will be dropped");
+  const audioLayers = doc.layers.filter((l) => l.visual.type === "audio");
+  if (audioLayers.length > 0) {
+    warnings.push(
+      `${audioLayers.length} audio layer(s) are not supported in Lottie format and will be dropped`
+    );
   }
   for (const delta of state.deltas) {
     if (isExpression22(delta.from) || isExpression22(delta.to)) {
@@ -4014,12 +4380,12 @@ function register11(server, store) {
     "atelier_export_svg",
     "Export a frame as an SVG string",
     {
-      id: z26.string().describe("Document ID"),
-      stateName: z26.string().optional().describe("State name (defaults to first state)"),
-      frame: z26.number().int().min(0).optional().describe("Frame number (defaults to 0)"),
-      xmlDeclaration: z26.boolean().optional().describe("Include XML declaration (default: false)"),
-      viewBox: z26.boolean().optional().describe("Include viewBox attribute (default: true)"),
-      indent: z26.number().int().min(0).optional().describe("Indent size in spaces (default: 2)")
+      id: z36.string().describe("Document ID"),
+      stateName: z36.string().optional().describe("State name (defaults to first state)"),
+      frame: z36.number().int().min(0).optional().describe("Frame number (defaults to 0)"),
+      xmlDeclaration: z36.boolean().optional().describe("Include XML declaration (default: false)"),
+      viewBox: z36.boolean().optional().describe("Include viewBox attribute (default: true)"),
+      indent: z36.number().int().min(0).optional().describe("Indent size in spaces (default: 2)")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frame, xmlDeclaration, viewBox, indent }) => {
@@ -4050,8 +4416,8 @@ function register11(server, store) {
     "atelier_export_lottie",
     "Export a document to Lottie JSON format (lossy, best-effort)",
     {
-      id: z26.string().describe("Document ID"),
-      stateName: z26.string().optional().describe("State to export (defaults to first state)")
+      id: z36.string().describe("Document ID"),
+      stateName: z36.string().optional().describe("State to export (defaults to first state)")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName }) => {
@@ -4071,7 +4437,7 @@ function register11(server, store) {
 }
 
 // ../mcp/src/tools/assets.ts
-import { z as z27 } from "zod";
+import { z as z37 } from "zod";
 function getDoc12(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4088,17 +4454,17 @@ function register12(server, store) {
     "atelier_add_asset",
     "Register an external asset (image, SVG, font, animation, audio) on a document",
     {
-      id: z27.string().describe("Document ID"),
-      assetId: z27.string().describe("Unique asset identifier"),
-      type: z27.enum(["image", "svg", "font", "animation", "audio"]).describe("Asset type"),
-      src: z27.string().describe("File path or URL"),
-      description: z27.string().optional().describe("Human-readable description"),
-      spritesheet: z27.object({
-        columns: z27.number().int().positive().describe("Number of columns in the spritesheet grid"),
-        rows: z27.number().int().positive().describe("Number of rows in the spritesheet grid"),
-        frameCount: z27.number().int().positive().optional().describe("Total frame count (defaults to columns \xD7 rows)"),
-        frameWidth: z27.number().positive().describe("Width of each frame in pixels"),
-        frameHeight: z27.number().positive().describe("Height of each frame in pixels")
+      id: z37.string().describe("Document ID"),
+      assetId: z37.string().describe("Unique asset identifier"),
+      type: z37.enum(["image", "svg", "font", "animation", "audio"]).describe("Asset type"),
+      src: z37.string().describe("File path or URL"),
+      description: z37.string().optional().describe("Human-readable description"),
+      spritesheet: z37.object({
+        columns: z37.number().int().positive().describe("Number of columns in the spritesheet grid"),
+        rows: z37.number().int().positive().describe("Number of rows in the spritesheet grid"),
+        frameCount: z37.number().int().positive().optional().describe("Total frame count (defaults to columns \xD7 rows)"),
+        frameWidth: z37.number().positive().describe("Width of each frame in pixels"),
+        frameHeight: z37.number().positive().describe("Height of each frame in pixels")
       }).optional().describe("Spritesheet metadata (image assets only)")
     },
     { readOnlyHint: false, destructiveHint: false },
@@ -4121,7 +4487,7 @@ function register12(server, store) {
     "atelier_list_assets",
     "List all registered assets with usage info (which layers/states reference them)",
     {
-      id: z27.string().describe("Document ID")
+      id: z37.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -4130,15 +4496,16 @@ function register12(server, store) {
       const { doc } = result;
       const assets = doc.assets ?? {};
       const entries = Object.entries(assets).map(([assetId, asset]) => {
-        const referencingLayers = doc.layers.filter((l) => l.visual.type === "image" && l.visual.assetId === assetId).map((l) => l.id);
-        const referencingStates = Object.entries(doc.states).filter(([, state]) => state.audio?.src === assetId).map(([name]) => name);
+        const referencingLayers = doc.layers.filter((l) => {
+          const v = l.visual;
+          return (v.type === "image" || v.type === "video" || v.type === "audio") && "assetId" in v && v.assetId === assetId;
+        }).map((l) => l.id);
         return {
           assetId,
           type: asset.type,
           src: asset.src,
           description: asset.description,
-          usedByLayers: referencingLayers,
-          usedByStates: referencingStates
+          usedByLayers: referencingLayers
         };
       });
       return ok12({ count: entries.length, assets: entries });
@@ -4146,10 +4513,10 @@ function register12(server, store) {
   );
   server.tool(
     "atelier_remove_asset",
-    "Remove a registered asset. Warns if layers or state audio still reference it.",
+    "Remove a registered asset. Warns if layers still reference it.",
     {
-      id: z27.string().describe("Document ID"),
-      assetId: z27.string().describe("Asset ID to remove")
+      id: z37.string().describe("Document ID"),
+      assetId: z37.string().describe("Asset ID to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, assetId }) => {
@@ -4158,14 +4525,13 @@ function register12(server, store) {
       const { doc } = result;
       if (!doc.assets?.[assetId]) return err12(`Asset "${assetId}" not found`);
       const warnings = [];
-      const referencingLayers = doc.layers.filter((l) => l.visual.type === "image" && l.visual.assetId === assetId).map((l) => l.id);
+      const referencingLayers = doc.layers.filter((l) => {
+        const v = l.visual;
+        return (v.type === "image" || v.type === "video" || v.type === "audio") && "assetId" in v && v.assetId === assetId;
+      }).map((l) => l.id);
       if (referencingLayers.length > 0) {
         warnings.push(`Asset is referenced by layer(s): ${referencingLayers.join(", ")}`);
       }
-      const referencingStates = Object.entries(doc.states).filter(([, state]) => state.audio?.src === assetId).map(([name]) => name);
-      if (referencingStates.length > 0) {
-        warnings.push(`Asset is referenced by state audio: ${referencingStates.join(", ")}`);
-      }
       delete doc.assets[assetId];
       return ok12({ assetId, warnings });
     }
@@ -4173,7 +4539,7 @@ function register12(server, store) {
 }
 
 // ../mcp/src/tools/variables.ts
-import { z as z28 } from "zod";
+import { z as z38 } from "zod";
 function getDoc13(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4190,11 +4556,11 @@ function register13(server, store) {
     "atelier_add_variable",
     "Define a template variable on a document",
     {
-      id: z28.string().describe("Document ID"),
-      variableName: z28.string().describe("Variable name (used in {{variableName}} patterns)"),
-      type: z28.enum(["string", "number", "color", "asset", "boolean"]).describe("Variable type"),
-      description: z28.string().optional().describe("Human-readable description"),
-      default: z28.unknown().optional().describe("Default value")
+      id: z38.string().describe("Document ID"),
+      variableName: z38.string().describe("Variable name (used in {{variableName}} patterns)"),
+      type: z38.enum(["string", "number", "color", "asset", "boolean"]).describe("Variable type"),
+      description: z38.string().optional().describe("Human-readable description"),
+      default: z38.unknown().optional().describe("Default value")
     },
     { readOnlyHint: false, destructiveHint: false },
     async (args) => {
@@ -4215,7 +4581,7 @@ function register13(server, store) {
     "atelier_list_variables",
     "List all declared variables with usage info (which {{references}} exist in the document)",
     {
-      id: z28.string().describe("Document ID")
+      id: z38.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -4239,8 +4605,8 @@ function register13(server, store) {
     "atelier_remove_variable",
     "Remove a declared variable. Warns if {{references}} still exist in the document.",
     {
-      id: z28.string().describe("Document ID"),
-      variableName: z28.string().describe("Variable name to remove")
+      id: z38.string().describe("Document ID"),
+      variableName: z38.string().describe("Variable name to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, variableName }) => {
@@ -4263,7 +4629,7 @@ function register13(server, store) {
 }
 
 // ../mcp/src/tools/interactions.ts
-import { z as z29 } from "zod";
+import { z as z39 } from "zod";
 function getDoc14(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4280,23 +4646,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: z29.string().describe("Document ID"),
-      layerId: z29.string().describe("Layer to attach the interaction to"),
-      interactionId: z29.string().describe("Unique interaction ID"),
-      trigger: z29.object({
-        type: z29.enum(["click", "hover", "pointerdown", "pointerup", "timer", "signal"]).describe("Trigger type"),
-        delay: z29.number().optional().describe("Delay in ms (timer trigger only)"),
-        signal: z29.string().optional().describe("Signal name (signal trigger only)")
+      id: z39.string().describe("Document ID"),
+      layerId: z39.string().describe("Layer to attach the interaction to"),
+      interactionId: z39.string().describe("Unique interaction ID"),
+      trigger: z39.object({
+        type: z39.enum(["click", "hover", "pointerdown", "pointerup", "timer", "signal"]).describe("Trigger type"),
+        delay: z39.number().optional().describe("Delay in ms (timer trigger only)"),
+        signal: z39.string().optional().describe("Signal name (signal trigger only)")
       }).describe("What triggers the interaction"),
-      action: z29.object({
-        type: z29.enum(["go-to-state", "emit-signal", "set-variable", "toggle-visibility"]).describe("Action type"),
-        state: z29.string().optional().describe("Target state (go-to-state only)"),
-        signal: z29.string().optional().describe("Signal to emit (emit-signal only)"),
-        variable: z29.string().optional().describe("Variable name (set-variable only)"),
-        value: z29.unknown().optional().describe("Value to set (set-variable only)"),
-        targetLayer: z29.string().optional().describe("Target layer ID (toggle-visibility, defaults to self)")
+      action: z39.object({
+        type: z39.enum(["go-to-state", "emit-signal", "set-variable", "toggle-visibility"]).describe("Action type"),
+        state: z39.string().optional().describe("Target state (go-to-state only)"),
+        signal: z39.string().optional().describe("Signal to emit (emit-signal only)"),
+        variable: z39.string().optional().describe("Variable name (set-variable only)"),
+        value: z39.unknown().optional().describe("Value to set (set-variable only)"),
+        targetLayer: z39.string().optional().describe("Target layer ID (toggle-visibility, defaults to self)")
       }).describe("What happens when triggered"),
-      description: z29.string().optional().describe("Human-readable description")
+      description: z39.string().optional().describe("Human-readable description")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, interactionId, trigger, action, description }) => {
@@ -4345,8 +4711,8 @@ function register14(server, store) {
     "atelier_list_interactions",
     "List all interactions across all layers or for a specific layer",
     {
-      id: z29.string().describe("Document ID"),
-      layerId: z29.string().optional().describe("Optional: filter to a specific layer")
+      id: z39.string().describe("Document ID"),
+      layerId: z39.string().optional().describe("Optional: filter to a specific layer")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, layerId }) => {
@@ -4373,9 +4739,9 @@ function register14(server, store) {
     "atelier_remove_interaction",
     "Remove an interaction from a layer",
     {
-      id: z29.string().describe("Document ID"),
-      layerId: z29.string().describe("Layer ID"),
-      interactionId: z29.string().describe("Interaction ID to remove")
+      id: z39.string().describe("Document ID"),
+      layerId: z39.string().describe("Layer ID"),
+      interactionId: z39.string().describe("Interaction ID to remove")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ id, layerId, interactionId }) => {
@@ -4397,7 +4763,7 @@ function register14(server, store) {
 }
 
 // ../mcp/src/tools/refs.ts
-import { z as z30 } from "zod";
+import { z as z40 } from "zod";
 function getDoc15(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4414,9 +4780,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: z30.string().describe("Document ID"),
-      layerId: z30.string().describe("Layer ID (must be a ref visual)"),
-      src: z30.string().describe("File path, URL, or in-memory document ID")
+      id: z40.string().describe("Document ID"),
+      layerId: z40.string().describe("Layer ID (must be a ref visual)"),
+      src: z40.string().describe("File path, URL, or in-memory document ID")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, layerId, src }) => {
@@ -4436,7 +4802,7 @@ function register15(server, store) {
     "atelier_resolve_refs",
     "Check which ref layers can be resolved (point to valid in-memory documents)",
     {
-      id: z30.string().describe("Document ID")
+      id: z40.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -4463,7 +4829,7 @@ function register15(server, store) {
 }
 
 // ../mcp/src/tools/performance.ts
-import { z as z31 } from "zod";
+import { z as z41 } from "zod";
 function getDoc16(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4480,9 +4846,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: z31.string().describe("Document ID"),
-      stateName: z31.string().describe("State name to profile"),
-      frame: z31.number().int().min(0).describe("Frame number to resolve")
+      id: z41.string().describe("Document ID"),
+      stateName: z41.string().describe("State name to profile"),
+      frame: z41.number().int().min(0).describe("Frame number to resolve")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frame }) => {
@@ -4528,10 +4894,10 @@ function register16(server, store) {
     "atelier_diff_frames",
     "Compare two frames and return only the properties that changed between them",
     {
-      id: z31.string().describe("Document ID"),
-      stateName: z31.string().describe("State name"),
-      frameA: z31.number().int().min(0).describe("First frame number"),
-      frameB: z31.number().int().min(0).describe("Second frame number")
+      id: z41.string().describe("Document ID"),
+      stateName: z41.string().describe("State name"),
+      frameA: z41.number().int().min(0).describe("First frame number"),
+      frameB: z41.number().int().min(0).describe("Second frame number")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id, stateName, frameA, frameB }) => {
@@ -4570,9 +4936,9 @@ function register16(server, store) {
     "atelier_batch_preview",
     "Preview multiple frames at once \u2014 reduces round-trips for scrubbing or timeline inspection",
     {
-      id: z31.string().describe("Document ID"),
-      stateName: z31.string().describe("State name to preview"),
-      frames: z31.array(z31.number().int().min(0)).min(1).max(60).describe("Array of frame numbers to resolve (max 60)")
+      id: z41.string().describe("Document ID"),
+      stateName: z41.string().describe("State name to preview"),
+      frames: z41.array(z41.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 }) => {
@@ -4608,7 +4974,7 @@ function register16(server, store) {
     "atelier_complexity",
     "Analyze document complexity \u2014 layer count, delta count, expression usage, state hierarchy depth",
     {
-      id: z31.string().describe("Document ID")
+      id: z41.string().describe("Document ID")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ id }) => {
@@ -4637,7 +5003,9 @@ function register16(server, store) {
           duration: state.duration,
           deltaCount,
           expressionCount,
-          hasAudio: !!state.audio,
+          // hasAudio removed in v1.0 — audio is no longer per-state, it's an
+          // AudioVisual layer. Audio-layer counts appear in the top-level
+          // layer stats below.
           hasParent: !!state.parent,
           transitionCount: state.transitions ? Object.keys(state.transitions).length : 0
         });
@@ -4681,7 +5049,7 @@ function register16(server, store) {
 }
 
 // ../mcp/src/tools/overlays.ts
-import { z as z32 } from "zod";
+import { z as z42 } from "zod";
 function getDoc17(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -4693,12 +5061,12 @@ function ok17(data) {
 function err17(message) {
   return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
 }
-var AnchorEnum = z32.enum(["top-left", "top-right", "bottom-left", "bottom-right"]);
-var OverlayStyleSchema = z32.object({
-  font_family: z32.string().optional(),
-  font_size: z32.number().positive().optional(),
-  font_weight: z32.union([z32.number(), z32.enum(["normal", "bold"])]).optional(),
-  color: z32.string().optional()
+var AnchorEnum = z42.enum(["top-left", "top-right", "bottom-left", "bottom-right"]);
+var OverlayStyleSchema = z42.object({
+  font_family: z42.string().optional(),
+  font_size: z42.number().positive().optional(),
+  font_weight: z42.union([z42.number(), z42.enum(["normal", "bold"])]).optional(),
+  color: z42.string().optional()
 }).optional();
 var DEFAULT_OVERLAY_MARGIN = 24;
 var DEFAULT_TEXT_STYLE = {
@@ -4749,12 +5117,12 @@ function register17(server, store) {
     "atelier_add_handle",
     "Add an anchored creator-handle TextVisual overlay layer (tag: overlay)",
     {
-      id: z32.string().describe("Document ID"),
-      text: z32.string().min(1).describe('Handle text, e.g. "@username"'),
+      id: z42.string().describe("Document ID"),
+      text: z42.string().min(1).describe('Handle text, e.g. "@username"'),
       anchor: AnchorEnum.describe("Anchored corner"),
-      margin: z32.number().nonnegative().optional().describe("Px from anchored edges (default 24)"),
+      margin: z42.number().nonnegative().optional().describe("Px from anchored edges (default 24)"),
       style: OverlayStyleSchema.describe("Text style overrides (snake_case to match recipe)"),
-      layerId: z32.string().optional().describe("Layer ID (default: overlay-handle)")
+      layerId: z42.string().optional().describe("Layer ID (default: overlay-handle)")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, text, anchor, margin, style, layerId }) => {
@@ -4784,14 +5152,14 @@ function register17(server, store) {
     "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: z32.string().describe("Document ID"),
-      format: z32.string().min(1).describe('Format string, e.g. "{current}/{total}" or "{current:02d}/{total:02d}"'),
+      id: z42.string().describe("Document ID"),
+      format: z42.string().min(1).describe('Format string, e.g. "{current}/{total}" or "{current:02d}/{total:02d}"'),
       anchor: AnchorEnum.describe("Anchored corner"),
-      currentIndex: z32.number().int().nonnegative().describe("1-based current index"),
-      totalCount: z32.number().int().positive().describe("Total count"),
-      margin: z32.number().nonnegative().optional().describe("Px from anchored edges (default 24)"),
+      currentIndex: z42.number().int().nonnegative().describe("1-based current index"),
+      totalCount: z42.number().int().positive().describe("Total count"),
+      margin: z42.number().nonnegative().optional().describe("Px from anchored edges (default 24)"),
       style: OverlayStyleSchema.describe("Text style overrides (snake_case to match recipe)"),
-      layerId: z32.string().optional().describe("Layer ID (default: overlay-page-number)")
+      layerId: z42.string().optional().describe("Layer ID (default: overlay-page-number)")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ id, format, anchor, currentIndex, totalCount, margin, style, layerId }) => {
@@ -4824,7 +5192,7 @@ function register17(server, store) {
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from "fs";
 import { join, resolve, isAbsolute, dirname } from "path";
 import { homedir } from "os";
-import { z as z33 } from "zod";
+import { z as z43 } from "zod";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function getDoc18(store, id) {
   const doc = store.get(id);
@@ -4991,7 +5359,7 @@ function register18(server, store) {
     "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: z33.string().optional().describe("Project root to search (default: process.cwd())")
+      projectDir: z43.string().optional().describe("Project root to search (default: process.cwd())")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ projectDir }) => {
@@ -5007,8 +5375,8 @@ function register18(server, store) {
     "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: z33.string().describe("Recipe path or bare name (resolved like the CLI)"),
-      projectDir: z33.string().optional().describe("Project root for name resolution (default: process.cwd())")
+      path: z43.string().describe("Recipe path or bare name (resolved like the CLI)"),
+      projectDir: z43.string().optional().describe("Project root for name resolution (default: process.cwd())")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ path, projectDir }) => {
@@ -5030,9 +5398,9 @@ function register18(server, store) {
     "atelier_recipe_validate",
     "Validate a recipe from a path OR inline YAML text. Returns { success, warnings, errors }.",
     {
-      path: z33.string().optional().describe("Recipe path or bare name to validate"),
-      yaml: z33.string().optional().describe("Inline YAML text to validate (alternative to path)"),
-      projectDir: z33.string().optional().describe("Project root for name resolution (default: process.cwd())")
+      path: z43.string().optional().describe("Recipe path or bare name to validate"),
+      yaml: z43.string().optional().describe("Inline YAML text to validate (alternative to path)"),
+      projectDir: z43.string().optional().describe("Project root for name resolution (default: process.cwd())")
     },
     { readOnlyHint: true, destructiveHint: false },
     async ({ path, yaml, projectDir }) => {
@@ -5062,9 +5430,9 @@ function register18(server, store) {
     "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: z33.string().describe("Absolute or relative file path to write the recipe to"),
-      recipe: z33.record(z33.unknown()).optional().describe("Recipe object (will be serialized to YAML)"),
-      yaml: z33.string().optional().describe("Raw YAML text (alternative to `recipe`)")
+      path: z43.string().describe("Absolute or relative file path to write the recipe to"),
+      recipe: z43.record(z43.unknown()).optional().describe("Recipe object (will be serialized to YAML)"),
+      yaml: z43.string().optional().describe("Raw YAML text (alternative to `recipe`)")
     },
     { readOnlyHint: false, destructiveHint: true },
     async ({ path, recipe, yaml }) => {
@@ -5102,12 +5470,12 @@ function register18(server, store) {
     "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: z33.string().describe("In-store document ID to apply the recipe to"),
-      path: z33.string().optional().describe("Recipe path or bare name (alternative to `recipe`)"),
-      recipe: z33.record(z33.unknown()).optional().describe("Recipe object (alternative to `path`)"),
-      projectDir: z33.string().optional().describe("Project root for name resolution (default: process.cwd())"),
-      currentIndex: z33.number().int().nonnegative().optional().describe("1-based carousel index for page_number"),
-      totalCount: z33.number().int().positive().optional().describe("Total carousel size for page_number")
+      documentId: z43.string().describe("In-store document ID to apply the recipe to"),
+      path: z43.string().optional().describe("Recipe path or bare name (alternative to `recipe`)"),
+      recipe: z43.record(z43.unknown()).optional().describe("Recipe object (alternative to `path`)"),
+      projectDir: z43.string().optional().describe("Project root for name resolution (default: process.cwd())"),
+      currentIndex: z43.number().int().nonnegative().optional().describe("1-based carousel index for page_number"),
+      totalCount: z43.number().int().positive().optional().describe("Total carousel size for page_number")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ documentId, path, recipe, projectDir, currentIndex, totalCount }) => {
@@ -5150,7 +5518,7 @@ function register18(server, store) {
 // ../mcp/src/tools/import-images.ts
 import { existsSync as existsSync2, readdirSync as readdirSync2, statSync } from "fs";
 import { resolve as resolve2, join as join2, basename, extname } from "path";
-import { z as z34 } from "zod";
+import { z as z44 } from "zod";
 function getDoc19(store, id) {
   const doc = store.get(id);
   if (!doc) return { error: `Document "${id}" not found` };
@@ -5198,10 +5566,10 @@ function register19(server, store) {
     "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: z34.string().describe("In-store document ID to import into"),
-      dir: z34.string().describe("Directory containing the images"),
-      glob: z34.string().optional().describe('Optional filename glob, e.g. "*.png" (default: all images)'),
-      asLayers: z34.boolean().optional().describe("Create layers per image (default: true). false = register assets only.")
+      documentId: z44.string().describe("In-store document ID to import into"),
+      dir: z44.string().describe("Directory containing the images"),
+      glob: z44.string().optional().describe('Optional filename glob, e.g. "*.png" (default: all images)'),
+      asLayers: z44.boolean().optional().describe("Create layers per image (default: true). false = register assets only.")
     },
     { readOnlyHint: false, destructiveHint: false },
     async ({ documentId, dir, glob, asLayers }) => {
@@ -5262,12 +5630,2023 @@ function register19(server, store) {
   );
 }
 
+// ../mcp/src/tools/mind-map.ts
+import { existsSync as existsSync3, statSync as statSync2, readdirSync as readdirSync3 } from "fs";
+import { resolve as resolve3, join as join3, basename as basename2, extname as extname2 } from "path";
+import { z as z45 } from "zod";
+function ok20(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err20(message) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+var KIND_EXTENSIONS = {
+  image: /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg", ".avif"]),
+  video: /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".mkv", ".avi"]),
+  audio: /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".ogg", ".flac", ".aac"]),
+  font: /* @__PURE__ */ new Set([".ttf", ".otf", ".woff", ".woff2"]),
+  text: /* @__PURE__ */ new Set(),
+  // empty by design — handled with a per-call note
+  voice: /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".ogg", ".flac", ".aac"]),
+  logo: /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg", ".avif"])
+};
+var TEXT_NOTE = "text slots resolve at composition time, not from disk";
+var MAX_DEPTH = 4;
+function chooseSearchRoot(projectDir) {
+  const mindMap = join3(projectDir, ".atelier", "mind-map");
+  if (existsSync3(mindMap) && statSync2(mindMap).isDirectory()) return mindMap;
+  const assets = join3(projectDir, "assets");
+  if (existsSync3(assets) && statSync2(assets).isDirectory()) return assets;
+  return projectDir;
+}
+function walk(root, searchedDirs) {
+  const out = [];
+  function recurse(dir, depth, relSegments) {
+    searchedDirs.push(dir);
+    let entries;
+    try {
+      entries = readdirSync3(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const abs = join3(dir, entry);
+      let stat;
+      try {
+        stat = statSync2(abs);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        if (depth >= MAX_DEPTH) continue;
+        recurse(abs, depth + 1, [...relSegments, entry]);
+      } else if (stat.isFile()) {
+        out.push({
+          path: abs,
+          name: entry,
+          mtimeMs: stat.mtimeMs,
+          relDirSegments: relSegments
+        });
+      }
+    }
+  }
+  recurse(root, 0, []);
+  return out;
+}
+function matchedHints(candidate, hints) {
+  const haystacks = [candidate.name.toLowerCase(), ...candidate.relDirSegments.map((s) => s.toLowerCase())];
+  return hints.filter((h) => {
+    const needle = h.toLowerCase();
+    return haystacks.some((hs) => hs.includes(needle));
+  });
+}
+var DEFAULT_LIMIT = 20;
+var MAX_LIMIT = 100;
+function register20(server, _store) {
+  server.tool(
+    "atelier_mind_map_query",
+    "Resolve a typed asset slot against the creator's local asset library. Walks <projectDir>/.atelier/mind-map/ (preferred), else <projectDir>/assets/, else <projectDir> itself. Recursive with a depth cap of 4 levels. Filters by the slot `kind` extension table (image, video, audio, font, voice, logo); `text` returns no matches by design (text resolves at composition time). Optional `hints` (case-insensitive substrings) narrow by filename or ancestor directory name within the search root. Results sorted by mtime (most-recent first). Pure read \u2014 does not touch the document store. Stub for Phase 4 mind-map.",
+    {
+      projectDir: z45.string().describe("Absolute or cwd-relative path to the project root"),
+      kind: SlotKindSchema.describe(
+        "Slot kind from the closed SlotKind enum (image|video|audio|text|font|voice|logo)"
+      ),
+      hints: z45.array(z45.string().min(1)).min(1).optional().describe(
+        "Optional case-insensitive substrings; a candidate must match at least one against its filename or an ancestor directory name within the search root."
+      ),
+      limit: z45.number().int().positive().max(MAX_LIMIT).optional().describe(`Max matches to return (default ${DEFAULT_LIMIT}, max ${MAX_LIMIT})`)
+    },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ projectDir, kind, hints, limit }) => {
+      const absProject = resolve3(projectDir);
+      if (!existsSync3(absProject)) {
+        return err20(`projectDir "${absProject}" does not exist`);
+      }
+      if (!statSync2(absProject).isDirectory()) {
+        return err20(`projectDir "${absProject}" is not a directory`);
+      }
+      const searchRoot = chooseSearchRoot(absProject);
+      const searchedDirs = [];
+      const candidates = walk(searchRoot, searchedDirs);
+      if (kind === "text") {
+        return ok20({
+          matches: [],
+          searched_dirs: searchedDirs,
+          total_candidates: candidates.length,
+          note: TEXT_NOTE
+        });
+      }
+      const allowedExts = KIND_EXTENSIONS[kind];
+      const kindMatched = candidates.filter((c) => allowedExts.has(extname2(c.name).toLowerCase()));
+      const hintFiltered = hints ? kindMatched.map((c) => ({ c, matched: matchedHints(c, hints) })).filter(({ matched }) => matched.length > 0) : kindMatched.map((c) => ({ c, matched: [] }));
+      hintFiltered.sort((a, b) => b.c.mtimeMs - a.c.mtimeMs);
+      const effectiveLimit = limit ?? DEFAULT_LIMIT;
+      const limited = hintFiltered.slice(0, effectiveLimit);
+      const matches = limited.map(({ c, matched }) => ({
+        path: c.path,
+        name: basename2(c.path),
+        kind,
+        matched_hints: matched
+      }));
+      return ok20({
+        matches,
+        searched_dirs: searchedDirs,
+        total_candidates: candidates.length
+      });
+    }
+  );
+}
+
+// ../mcp/src/tools/effective-transcript.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2, statSync as statSync3, readdirSync as readdirSync4 } from "fs";
+import { createHash } from "crypto";
+import { join as join4, resolve as resolve4 } from "path";
+import { z as z46 } from "zod";
+function ok21(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err21(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+function applyCuts(transcript, cuts, options) {
+  const sortedCuts = [...cuts].sort((a, b) => a.rawStart - b.rawStart);
+  const keepRanges = sortedCuts.map((c) => ({
+    start: Math.max(0, c.rawStart - c.paddingPre),
+    end: c.rawEnd + c.paddingPost
+  }));
+  function mapTime(t) {
+    let cumulativeOffset = 0;
+    for (const r of keepRanges) {
+      if (t < r.start) return null;
+      if (t <= r.end) return t - r.start + cumulativeOffset;
+      cumulativeOffset += r.end - r.start;
+    }
+    return null;
+  }
+  const newSegments = [];
+  for (const seg of transcript.segments) {
+    const newWords = [];
+    for (const w of seg.words) {
+      const ns = mapTime(w.start);
+      const ne = mapTime(w.end);
+      if (ns === null || ne === null) continue;
+      newWords.push({ ...w, start: ns, end: ne });
+    }
+    if (newWords.length === 0) continue;
+    newSegments.push({
+      text: seg.text,
+      start: newWords[0].start,
+      end: newWords[newWords.length - 1].end,
+      words: newWords
+    });
+  }
+  const totalCutDurationS = keepRanges.reduce((sum, r) => sum + (r.end - r.start), 0);
+  const derived_from = {
+    transcriptName: options.transcriptName,
+    cutsHash: options.cutsHash,
+    derivedAt: options.derivedAt,
+    cutsApplied: sortedCuts.length,
+    totalCutDurationS
+  };
+  return {
+    version: transcript.version,
+    ...transcript.language !== void 0 && { language: transcript.language },
+    segments: newSegments,
+    derived_from
+  };
+}
+function hashCuts(cuts) {
+  const canonical = cuts.map((c) => [c.rawStart, c.rawEnd, c.paddingPre, c.paddingPost]);
+  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
+}
+function discoverTranscripts(projectDir) {
+  const out = [];
+  const canonical = join4(projectDir, "transcript.json");
+  if (existsSync4(canonical) && statSync3(canonical).isFile()) {
+    out.push({ absPath: canonical, name: "transcript.json" });
+  }
+  const transcriptsDir = join4(projectDir, "transcripts");
+  if (existsSync4(transcriptsDir) && statSync3(transcriptsDir).isDirectory()) {
+    try {
+      const entries = readdirSync4(transcriptsDir).filter((f) => f.endsWith(".json")).sort();
+      for (const entry of entries) {
+        out.push({
+          absPath: join4(transcriptsDir, entry),
+          name: `transcripts/${entry}`
+        });
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function register21(server, _store) {
+  server.tool(
+    "atelier_get_effective_transcript",
+    "Read a project's raw transcript.json + cuts.json and return the post-cut (effective) transcript \u2014 words inside cut gaps dropped, surviving timestamps shifted to the trimmed timeline. Pure read; does not touch the document store. When cuts.json is absent or has zero cuts, returns the raw transcript verbatim (no `derived_from` stamp). Optional `transcriptName` disambiguates when the project carries multiple transcripts (transcripts/*.json); without it, transcript.json wins, and an error is returned if multiple sit in transcripts/.",
+    {
+      projectDir: z46.string().describe("Absolute or cwd-relative project root"),
+      transcriptName: z46.string().optional().describe(
+        "Optional transcript filename (e.g. 'transcript.json' or 'transcripts/take-2.json'). Disambiguates multi-transcript projects."
+      )
+    },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ projectDir, transcriptName }) => {
+      const absProject = resolve4(projectDir);
+      if (!existsSync4(absProject)) {
+        return err21(`projectDir "${absProject}" does not exist`);
+      }
+      if (!statSync3(absProject).isDirectory()) {
+        return err21(`projectDir "${absProject}" is not a directory`);
+      }
+      let chosen;
+      if (transcriptName !== void 0) {
+        const absPath = transcriptName.startsWith("/") ? transcriptName : join4(absProject, transcriptName);
+        if (!existsSync4(absPath) || !statSync3(absPath).isFile()) {
+          return err21(`transcript "${transcriptName}" not found in ${absProject}`);
+        }
+        chosen = { absPath, name: transcriptName };
+      } else {
+        const candidates = discoverTranscripts(absProject);
+        if (candidates.length === 0) {
+          return err21(`no transcript found in ${absProject} (looked for transcript.json and transcripts/*.json)`);
+        }
+        if (candidates.length > 1) {
+          return err21(
+            `multiple transcripts present in ${absProject}; pass transcriptName explicitly. Candidates: ${candidates.map((c) => c.name).join(", ")}`
+          );
+        }
+        chosen = candidates[0];
+      }
+      let rawTranscript;
+      try {
+        rawTranscript = JSON.parse(readFileSync2(chosen.absPath, "utf-8"));
+      } catch (e) {
+        return err21(`failed to parse transcript at ${chosen.absPath}: ${e.message}`);
+      }
+      const cutsPath = join4(absProject, "cuts.json");
+      if (!existsSync4(cutsPath)) {
+        return ok21({
+          effective: rawTranscript,
+          source: {
+            transcriptName: chosen.name,
+            cutsApplied: 0,
+            totalCutDurationS: 0
+          }
+        });
+      }
+      let rawCuts;
+      try {
+        rawCuts = JSON.parse(readFileSync2(cutsPath, "utf-8"));
+      } catch (e) {
+        return err21(`failed to parse cuts at ${cutsPath}: ${e.message}`);
+      }
+      const cuts = rawCuts.cuts ?? [];
+      if (cuts.length === 0) {
+        return ok21({
+          effective: rawTranscript,
+          source: {
+            transcriptName: chosen.name,
+            cutsApplied: 0,
+            totalCutDurationS: 0
+          }
+        });
+      }
+      const effective = applyCuts(rawTranscript, cuts, {
+        transcriptName: chosen.name,
+        cutsHash: hashCuts(cuts),
+        derivedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return ok21({
+        effective,
+        source: {
+          transcriptName: chosen.name,
+          cutsApplied: effective.derived_from?.cutsApplied ?? cuts.length,
+          totalCutDurationS: effective.derived_from?.totalCutDurationS ?? 0
+        }
+      });
+    }
+  );
+}
+
+// ../mcp/src/tools/media-notes.ts
+import { existsSync as existsSync5, readFileSync as readFileSync3, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5, resolve as resolve5 } from "path";
+import { z as z47 } from "zod";
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+function ok22(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err22(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+var MEDIA_NOTES_SUFFIX = ".notes.md";
+function resolveMediaPaths(projectDir, filename) {
+  const absProject = resolve5(projectDir);
+  if (!existsSync5(absProject) || !statSync4(absProject).isDirectory()) {
+    return { error: `projectDir "${absProject}" is not a directory` };
+  }
+  if (filename.includes("/") || filename.includes("\\") || filename === "..") {
+    return { error: `filename must be a bare basename (got "${filename}")` };
+  }
+  const mediaPath = join5(absProject, "media", filename);
+  const notesPath = `${mediaPath}${MEDIA_NOTES_SUFFIX}`;
+  return { project: absProject, mediaPath, notesPath };
+}
+function splitFrontmatter(raw) {
+  const trimmed = raw.replace(/^/, "");
+  if (!trimmed.startsWith("---")) return null;
+  const lines = trimmed.split(/\r?\n/);
+  if (lines[0].trim() !== "---") return null;
+  let closeIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") {
+      closeIdx = i;
+      break;
+    }
+  }
+  if (closeIdx === -1) return null;
+  return {
+    frontmatter: lines.slice(1, closeIdx).join("\n"),
+    body: lines.slice(closeIdx + 1).join("\n").replace(/^\n+/, "")
+  };
+}
+function readNotesFile(notesPath) {
+  if (!existsSync5(notesPath)) return null;
+  const raw = readFileSync3(notesPath, "utf-8");
+  const split = splitFrontmatter(raw);
+  if (split === null) return null;
+  let parsed;
+  try {
+    parsed = parseYaml2(split.frontmatter);
+  } catch {
+    return null;
+  }
+  const validated = MediaNotesFrontmatterSchema.safeParse(parsed);
+  if (!validated.success) return null;
+  return { frontmatter: validated.data, body: split.body };
+}
+function writeNotesFile(notesPath, notes) {
+  const yamlText = stringifyYaml2(notes.frontmatter);
+  const body = notes.body.endsWith("\n") ? notes.body : `${notes.body}
+`;
+  writeFileSync2(notesPath, `---
+${yamlText}---
+
+${body}`, "utf-8");
+}
+function upsertSection(body, heading, newBlock) {
+  const lines = body.split(/\r?\n/);
+  let startIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim() === heading) {
+      startIdx = i;
+      break;
+    }
+  }
+  if (startIdx === -1) {
+    const existing = body.trimEnd();
+    return existing.length > 0 ? `${existing}
+
+${newBlock.trimEnd()}
+` : `${newBlock.trimEnd()}
+`;
+  }
+  let endIdx = lines.length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    if (lines[i].startsWith("## ")) {
+      endIdx = i;
+      break;
+    }
+  }
+  const before = lines.slice(0, startIdx);
+  const after = lines.slice(endIdx);
+  const replacement = newBlock.split(/\r?\n/);
+  while (replacement.length > 0 && replacement[replacement.length - 1] === "") {
+    replacement.pop();
+  }
+  const joined = [...before, ...replacement];
+  if (after.length > 0 && after[0].startsWith("## ")) {
+    joined.push("");
+  }
+  joined.push(...after);
+  return joined.join("\n").replace(/\n+$/, "\n");
+}
+function register22(server, _store) {
+  server.tool(
+    "atelier_get_media_notes",
+    "Read the sidecar notes file for a media entry \u2014 <projectDir>/media/<filename>.notes.md. Returns the parsed frontmatter (file, added, added_by, tags, optional constraints) plus the Markdown body. Returns an error envelope when the notes file is absent or malformed; pure read, does not touch the document store.",
+    {
+      projectDir: z47.string().describe("Absolute or cwd-relative project root"),
+      filename: z47.string().describe("Bare basename of the media file (e.g. 'b-roll-laptop.mp4')")
+    },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ projectDir, filename }) => {
+      const paths = resolveMediaPaths(projectDir, filename);
+      if ("error" in paths) return err22(paths.error);
+      if (!existsSync5(paths.notesPath)) {
+        return err22(`notes file not found: ${paths.notesPath}`);
+      }
+      const notes = readNotesFile(paths.notesPath);
+      if (notes === null) {
+        return err22(`notes file at ${paths.notesPath} is malformed (frontmatter parse / schema validation failed)`);
+      }
+      return ok22({
+        path: paths.notesPath,
+        frontmatter: notes.frontmatter,
+        body: notes.body
+      });
+    }
+  );
+  server.tool(
+    "atelier_write_media_note",
+    "Append or replace an author's section in a media file's sidecar notes. Section boundaries are detected by the per-author sentinel headings (## Lux notes / Quill notes / Iris notes / Creator notes); a second call with the same author replaces the prior section rather than duplicating. The notes file MUST exist already (scaffold via `atelier media ingest` or `atelier media note`). Mutates disk; the calling agent is tagged via the `author` argument.",
+    {
+      projectDir: z47.string().describe("Absolute or cwd-relative project root"),
+      filename: z47.string().describe("Bare basename of the media file"),
+      author: MediaNotesAuthorSchema.describe("Section owner: lux | quill | iris | creator"),
+      section: z47.string().describe("Markdown body for the section (heading is added automatically)")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ projectDir, filename, author, section }) => {
+      const paths = resolveMediaPaths(projectDir, filename);
+      if ("error" in paths) return err22(paths.error);
+      if (!existsSync5(paths.notesPath)) {
+        return err22(
+          `notes file not found: ${paths.notesPath} \u2014 scaffold via \`atelier media ingest\` or \`atelier media note\` first`
+        );
+      }
+      const existing = readNotesFile(paths.notesPath);
+      if (existing === null) {
+        return err22(
+          `notes file at ${paths.notesPath} is malformed \u2014 refusing to write into a file with unparseable frontmatter`
+        );
+      }
+      const typedAuthor = author;
+      const heading = MEDIA_NOTES_HEADINGS[typedAuthor];
+      const trimmed = section.trim();
+      const newBlock = `${heading}
+${trimmed}
+`;
+      const hasExistingSection = existing.body.split(/\r?\n/).some((l) => l.trim() === heading);
+      const updatedBody = upsertSection(existing.body, heading, newBlock);
+      const updated = { frontmatter: existing.frontmatter, body: updatedBody };
+      writeNotesFile(paths.notesPath, updated);
+      return ok22({
+        path: paths.notesPath,
+        action: hasExistingSection ? "replaced" : "appended",
+        author: typedAuthor
+      });
+    }
+  );
+}
+
+// ../mcp/src/tools/clips.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { basename as basename4, extname as extname4, isAbsolute as isAbsolute2, join as join6, resolve as resolve6 } from "path";
+import { z as z48 } from "zod";
+
+// ../mcp/src/lib/timeline-ops.ts
+import { basename as basename3, extname as extname3 } from "path";
+import { spawn } from "child_process";
+var VIDEO_TRACK_ID = "track-video-1";
+var AUDIO_TRACK_ID = "track-audio-1";
+function slugifyBasename(name) {
+  const base = basename3(name);
+  const stem = stripExt(base);
+  const lower = stem.toLowerCase();
+  const replaced = lower.replace(/[^a-z0-9]+/g, "-");
+  return replaced.replace(/^-+|-+$/g, "");
+}
+function stripExt(name) {
+  const ext = extname3(name);
+  return ext ? name.slice(0, -ext.length) : name;
+}
+function endOfTrackFrame(layers, trackId, fps) {
+  let maxEnd = 0;
+  for (const layer of layers) {
+    if (layer.parentId !== trackId) continue;
+    const v = layer.visual;
+    if (v.type !== "video" && v.type !== "audio") continue;
+    const tv = v;
+    const start = tv.startFrame ?? 0;
+    const offset = tv.sourceOffset ?? 0;
+    const end = tv.sourceEnd;
+    if (end === void 0) continue;
+    const durFrames = Math.max(0, Math.round((end - offset) * fps));
+    const layerEnd = start + durFrames;
+    if (layerEnd > maxEnd) maxEnd = layerEnd;
+  }
+  return maxEnd;
+}
+function ensureTrackLayer(doc, trackId, kind) {
+  const exists = doc.layers.some((l) => l.id === trackId);
+  if (exists) return { doc, created: false };
+  const trackLayer = {
+    id: trackId,
+    tags: ["track", kind],
+    description: kind === "video" ? "Video track 1" : "Audio track 1",
+    visual: { type: "group" },
+    frame: { x: 0, y: 0 },
+    bounds: { width: doc.canvas.width, height: doc.canvas.height }
+  };
+  return {
+    doc: { ...doc, layers: [trackLayer, ...doc.layers] },
+    created: true
+  };
+}
+function ensureClipLayer(doc, args) {
+  const existing = doc.layers.find((l) => l.id === args.clipLayerId);
+  if (existing) {
+    return { doc, addedLayer: false, clipLayerId: args.clipLayerId };
+  }
+  const ensured = ensureTrackLayer(doc, args.trackId, args.kind);
+  const working = ensured.doc;
+  const startFrame = args.startFrame !== void 0 ? args.startFrame : endOfTrackFrame(working.layers, args.trackId, working.canvas.fps);
+  const sourceOffset = args.sourceOffset ?? 0;
+  const sourceEnd = args.sourceEnd ?? args.clipDurationSeconds;
+  const newAsset = {
+    type: args.kind === "video" ? "video" : "audio",
+    src: args.sourceName,
+    description: `Source: ${args.sourceName}`
+  };
+  const assets = {
+    ...working.assets ?? {},
+    [args.clipLayerId]: newAsset
+  };
+  let newClip;
+  if (args.kind === "video") {
+    const visual = {
+      type: "video",
+      assetId: args.clipLayerId,
+      src: args.sourceName,
+      startFrame,
+      sourceOffset,
+      sourceEnd,
+      playbackRate: 1,
+      objectFit: "contain"
+    };
+    newClip = {
+      id: args.clipLayerId,
+      parentId: args.trackId,
+      visual,
+      frame: { x: 0, y: 0 },
+      bounds: { width: working.canvas.width, height: working.canvas.height }
+    };
+  } else {
+    const visual = {
+      type: "audio",
+      assetId: args.clipLayerId,
+      src: args.sourceName,
+      startFrame,
+      sourceOffset,
+      sourceEnd
+    };
+    newClip = {
+      id: args.clipLayerId,
+      parentId: args.trackId,
+      visual,
+      frame: { x: 0, y: 0 },
+      bounds: { width: 0, height: 0 }
+    };
+  }
+  return {
+    doc: {
+      ...working,
+      assets,
+      layers: [...working.layers, newClip]
+    },
+    addedLayer: true,
+    clipLayerId: args.clipLayerId
+  };
+}
+function recomputeTimeline(doc) {
+  const fps = doc.canvas.fps;
+  const trackGroups = doc.layers.filter(
+    (l) => l.visual.type === "group" && (l.tags ?? []).includes("track")
+  );
+  if (trackGroups.length === 0) {
+    if (doc.timeline === void 0) return doc;
+    const { timeline: _omit, ...rest } = doc;
+    void _omit;
+    return rest;
+  }
+  const tracks = [];
+  let totalFrames = 0;
+  for (const track of trackGroups) {
+    const tags = track.tags ?? [];
+    const kind = tags.includes("audio") ? "audio" : "video";
+    const children = doc.layers.filter(
+      (l) => l.parentId === track.id && l.visual.type === kind
+    );
+    const clips = children.map((layer) => {
+      const v = layer.visual;
+      const start = v.startFrame ?? 0;
+      const offset = v.sourceOffset ?? 0;
+      const end = v.sourceEnd ?? offset;
+      const durFrames = Math.max(0, Math.round((end - offset) * fps));
+      return {
+        layerId: layer.id,
+        startFrame: start,
+        endFrame: start + durFrames,
+        source: v.src ?? ""
+      };
+    }).sort((a, b) => a.startFrame - b.startFrame);
+    const trackEnd = clips.reduce((m, c) => Math.max(m, c.endFrame), 0);
+    if (trackEnd > totalFrames) totalFrames = trackEnd;
+    tracks.push({ id: track.id, kind, clips });
+  }
+  const timeline = { fps, totalFrames, tracks };
+  return { ...doc, timeline };
+}
+var DEFAULT_STYLE = {
+  fontFamily: "Inter",
+  fontSize: 84,
+  fontWeight: "bold",
+  textAlign: "center",
+  color: "#FFFFFF",
+  yRatio: 0.85,
+  widthRatio: 0.9,
+  fadeSeconds: 0.05
+};
+var DEFAULT_PHRASE_MAX_WORDS = 5;
+var DEFAULT_PHRASE_PAUSE_GAP_SECONDS = 0.4;
+var END_PUNCT = /[.!?,;:]\s*$/;
+function flattenWords(transcript) {
+  return transcript.segments.flatMap((s) => s.words);
+}
+function groupIntoPhrases(transcript, options = {}) {
+  const maxWords = options.maxWords ?? DEFAULT_PHRASE_MAX_WORDS;
+  const pauseGap = options.pauseGap ?? DEFAULT_PHRASE_PAUSE_GAP_SECONDS;
+  const phrases = [];
+  const visibleWords = flattenWords(transcript).filter((w) => !w.hidden);
+  let current = [];
+  for (let i = 0; i < visibleWords.length; i++) {
+    const w = visibleWords[i];
+    current.push(w);
+    const next = visibleWords[i + 1];
+    const gap = next ? next.start - w.end : 0;
+    const endsOnPunct = END_PUNCT.test(w.text);
+    const atMax = current.length >= maxWords;
+    if (!next || atMax || endsOnPunct || gap > pauseGap) {
+      phrases.push({
+        start: current[0].start,
+        end: current[current.length - 1].end,
+        text: current.map((c) => c.text).join(" "),
+        words: current
+      });
+      current = [];
+    }
+  }
+  return phrases;
+}
+function buildCaptionLayers(transcript, canvas, options = {}) {
+  const style = { ...DEFAULT_STYLE, ...options.style };
+  const phrases = groupIntoPhrases(transcript, {
+    maxWords: options.maxWords,
+    pauseGap: options.pauseGap
+  });
+  const layers = [];
+  const deltas = [];
+  const fps = canvas.fps;
+  phrases.forEach((phrase, idx) => {
+    const layerId = `caption-${idx}`;
+    layers.push(buildPhraseLayer(layerId, phrase, canvas, style));
+    deltas.push(...buildPhraseDeltas(layerId, phrase, style.fadeSeconds, fps));
+  });
+  return { layers, deltas };
+}
+function buildPhraseLayer(id, phrase, canvas, style) {
+  return {
+    id,
+    tags: ["caption"],
+    visual: {
+      type: "text",
+      content: phrase.text,
+      style: {
+        fontFamily: style.fontFamily,
+        fontSize: style.fontSize,
+        fontWeight: style.fontWeight,
+        textAlign: style.textAlign,
+        color: style.color
+      }
+    },
+    frame: {
+      x: canvas.width / 2,
+      y: canvas.height * style.yRatio
+    },
+    bounds: {
+      width: canvas.width * style.widthRatio,
+      height: Math.max(120, style.fontSize * 1.6)
+    },
+    anchorPoint: { x: 0.5, y: 0.5 },
+    opacity: 0
+  };
+}
+function buildPhraseDeltas(layerId, phrase, fadeSeconds, fps) {
+  const fadeFrames = Math.max(1, Math.round(fadeSeconds * fps));
+  const startFrame = Math.floor(phrase.start * fps);
+  const endFrame = Math.ceil(phrase.end * fps);
+  const fadeOutStart = Math.max(startFrame + 1, endFrame - fadeFrames);
+  return [
+    {
+      layer: layerId,
+      property: "opacity",
+      range: [Math.max(0, startFrame - fadeFrames), startFrame],
+      from: 0,
+      to: 1,
+      easing: "ease-out"
+    },
+    {
+      layer: layerId,
+      property: "opacity",
+      range: [fadeOutStart, endFrame],
+      from: 1,
+      to: 0,
+      easing: "ease-in"
+    }
+  ];
+}
+function stripCaptionsForClip(doc, clipLayerId) {
+  const droppedIds = /* @__PURE__ */ new Set();
+  const keptLayers = doc.layers.filter((layer) => {
+    if (!(layer.tags ?? []).includes("caption")) return true;
+    if (layer.parentId === clipLayerId) {
+      droppedIds.add(layer.id);
+      return false;
+    }
+    return true;
+  });
+  if (droppedIds.size === 0) return doc;
+  const states = {};
+  for (const [name, st] of Object.entries(doc.states)) {
+    states[name] = {
+      ...st,
+      deltas: st.deltas.filter((d) => !droppedIds.has(d.layer))
+    };
+  }
+  return { ...doc, layers: keptLayers, states };
+}
+function rebuildClipCaptions(doc, clipLayerId, transcript, canvas, captionOptions) {
+  const clipSlug = clipLayerId.startsWith("clip-") ? clipLayerId.slice("clip-".length) : clipLayerId;
+  let working = stripCaptionsForClip(doc, clipLayerId);
+  const built = buildCaptionLayers(transcript, canvas, captionOptions ?? {});
+  const idMap = /* @__PURE__ */ new Map();
+  const renamedLayers = built.layers.map((layer, idx) => {
+    const newId = `cap-${clipSlug}-${idx}`;
+    idMap.set(layer.id, newId);
+    return { ...layer, id: newId, parentId: clipLayerId };
+  });
+  const renamedDeltas = built.deltas.map((d) => ({
+    ...d,
+    layer: idMap.get(d.layer) ?? d.layer
+  }));
+  working = { ...working, layers: [...working.layers, ...renamedLayers] };
+  const stateNames = Object.keys(working.states);
+  const targetStateName = stateNames.includes("default") ? "default" : stateNames[0] ?? "default";
+  const states = { ...working.states };
+  const existing = states[targetStateName];
+  if (existing) {
+    states[targetStateName] = {
+      ...existing,
+      deltas: [...existing.deltas, ...renamedDeltas]
+    };
+  } else {
+    states[targetStateName] = { duration: 0, deltas: renamedDeltas };
+  }
+  return { ...working, states };
+}
+async function probeDuration(sourcePath) {
+  const stdout = await runCapture("ffprobe", [
+    "-v",
+    "error",
+    "-show_entries",
+    "format=duration",
+    "-of",
+    "csv=p=0",
+    sourcePath
+  ]);
+  const n = parseFloat(stdout.trim());
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(`ffprobe returned invalid duration for ${sourcePath}: "${stdout}"`);
+  }
+  return n;
+}
+function runCapture(cmd, args) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(cmd, args);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolvePromise(stdout);
+      else reject(new Error(`${cmd} exited ${code}: ${stderr}`));
+    });
+  });
+}
+
+// ../mcp/src/tools/clips.ts
+function ok23(data) {
+  return { content: [{ type: "text", text: JSON.stringify({ success: true, ...data }) }] };
+}
+function err23(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+function loadDocFromDisk(projectDir) {
+  const absProject = resolve6(projectDir);
+  const compositionPath = join6(absProject, "project.atelier");
+  if (!existsSync6(compositionPath)) {
+    return { error: `project.atelier not found at ${compositionPath}` };
+  }
+  let raw;
+  try {
+    raw = readFileSync4(compositionPath, "utf-8");
+  } catch (e) {
+    return { error: `failed to read ${compositionPath}: ${e.message}` };
+  }
+  let doc;
+  try {
+    doc = JSON.parse(raw);
+  } catch (e) {
+    return { error: `failed to parse ${compositionPath}: ${e.message}` };
+  }
+  return { doc, compositionPath };
+}
+function persistDoc(store, documentId, doc, compositionPath) {
+  writeFileSync3(compositionPath, JSON.stringify(doc, null, 2), "utf-8");
+  if (store.has(documentId)) {
+    store.set(documentId, doc, "llm");
+  } else {
+    store.create(doc, documentId, "llm");
+  }
+}
+function canonicalSourceName(source, projectDir) {
+  const absProject = resolve6(projectDir);
+  const abs = isAbsolute2(source) ? source : resolve6(absProject, source);
+  if (abs.startsWith(`${absProject}/`)) {
+    return { srcRef: abs.slice(absProject.length + 1), absPath: abs };
+  }
+  return { srcRef: basename4(abs), absPath: abs };
+}
+function clipEndFrame(visual, fps) {
+  const start = visual.startFrame ?? 0;
+  const offset = visual.sourceOffset ?? 0;
+  const end = visual.sourceEnd ?? offset;
+  const durFrames = Math.max(0, Math.round((end - offset) * fps));
+  return start + durFrames;
+}
+var injectedTranscribeFn;
+var injectedProbeDurationFn;
+function __setTranscribeClipFn(fn) {
+  injectedTranscribeFn = fn;
+}
+function __setProbeDurationFn(fn) {
+  injectedProbeDurationFn = fn;
+}
+function register23(server, store) {
+  server.tool(
+    "atelier_add_clip",
+    "Register a media source as a clip layer on a video or audio track. Idempotent: re-running with the same source preserves the existing clip's placement and applies only explicitly-passed startFrame/sourceOffset/sourceEnd overrides.",
+    {
+      documentId: z48.string().describe("In-memory document ID to reload after disk write"),
+      projectDir: z48.string().describe("Absolute path to the project root (contains project.atelier)"),
+      source: z48.string().describe("Absolute media path OR project-relative path (e.g. media/clip.mp4)"),
+      kind: z48.enum(["video", "audio"]).optional().describe("Clip kind (default: video)"),
+      trackId: z48.string().optional().describe("Track layer id (default: track-video-1 / track-audio-1)"),
+      startFrame: z48.number().int().nonnegative().optional().describe("Composition-frame start (default: end-of-track)"),
+      sourceOffset: z48.number().nonnegative().optional().describe("Seconds into source to begin from"),
+      sourceEnd: z48.number().positive().optional().describe("Seconds into source to stop at"),
+      layerIdHint: z48.string().optional().describe("Explicit layer id override (default: clip-<slug> or aud-<slug>)")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, projectDir, source, kind, trackId, startFrame, sourceOffset, sourceEnd, layerIdHint }) => {
+      const loaded = loadDocFromDisk(projectDir);
+      if ("error" in loaded) return err23(loaded.error);
+      let { doc } = loaded;
+      const { compositionPath } = loaded;
+      const clipKind = kind ?? "video";
+      const resolvedTrackId = trackId ?? (clipKind === "video" ? VIDEO_TRACK_ID : AUDIO_TRACK_ID);
+      const { srcRef, absPath } = canonicalSourceName(source, projectDir);
+      const slug = slugifyBasename(srcRef);
+      if (!slug) return err23(`cannot derive a slug from source "${source}"`);
+      const layerId = layerIdHint ?? (clipKind === "video" ? `clip-${slug}` : `aud-${slug}`);
+      const probeFn = injectedProbeDurationFn ?? probeDuration;
+      let clipDurationSeconds = 0;
+      try {
+        clipDurationSeconds = await probeFn(absPath);
+      } catch {
+        clipDurationSeconds = 0;
+      }
+      const fps = doc.canvas.fps;
+      const clipDurationFrames = Math.max(1, Math.round(clipDurationSeconds * fps));
+      const existing = doc.layers.find((l) => l.id === layerId);
+      let addedLayer = false;
+      if (existing) {
+        if (existing.visual.type !== clipKind) {
+          return err23(`layer "${layerId}" exists but is type "${existing.visual.type}", not "${clipKind}"`);
+        }
+        const v = existing.visual;
+        const patched = { ...v };
+        if (startFrame !== void 0) patched.startFrame = startFrame;
+        if (sourceOffset !== void 0) patched.sourceOffset = sourceOffset;
+        if (sourceEnd !== void 0) patched.sourceEnd = sourceEnd;
+        doc = {
+          ...doc,
+          layers: doc.layers.map((l) => l.id === layerId ? { ...l, visual: patched } : l)
+        };
+      } else {
+        const ensured = ensureClipLayer(doc, {
+          clipLayerId: layerId,
+          trackId: resolvedTrackId,
+          sourceName: srcRef,
+          clipDurationSeconds,
+          clipDurationFrames,
+          kind: clipKind,
+          ...startFrame !== void 0 ? { startFrame } : {},
+          ...sourceOffset !== void 0 ? { sourceOffset } : {},
+          ...sourceEnd !== void 0 ? { sourceEnd } : {}
+        });
+        doc = ensured.doc;
+        addedLayer = ensured.addedLayer;
+      }
+      doc = recomputeTimeline(doc);
+      const final = doc.layers.find((l) => l.id === layerId);
+      if (!final) return err23(`internal: layer "${layerId}" missing after ensureClipLayer`);
+      const visual = final.visual;
+      const resolvedStart = visual.startFrame ?? 0;
+      const resolvedEnd = clipEndFrame(visual, fps);
+      persistDoc(store, documentId, doc, compositionPath);
+      return ok23({
+        layerId,
+        trackId: resolvedTrackId,
+        startFrame: resolvedStart,
+        endFrame: resolvedEnd,
+        addedLayer
+      });
+    }
+  );
+  server.tool(
+    "atelier_move_clip",
+    "Shift a clip's composition-frame start. Caption layers parented to the clip stay aligned automatically (renderer uses clip-local time). Recomputes the timeline.",
+    {
+      documentId: z48.string().describe("In-memory document ID to reload after disk write"),
+      projectDir: z48.string().describe("Absolute path to the project root"),
+      layerId: z48.string().describe("Layer id of the clip to move"),
+      newStartFrame: z48.number().int().nonnegative().describe("New composition-frame start")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, projectDir, layerId, newStartFrame }) => {
+      const loaded = loadDocFromDisk(projectDir);
+      if ("error" in loaded) return err23(loaded.error);
+      let { doc } = loaded;
+      const { compositionPath } = loaded;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err23(`clip layer "${layerId}" not found`);
+      if (layer.visual.type !== "video" && layer.visual.type !== "audio") {
+        return err23(`layer "${layerId}" is type "${layer.visual.type}", not a clip`);
+      }
+      const oldVisual = layer.visual;
+      const oldStartFrame = oldVisual.startFrame ?? 0;
+      const newVisual = { ...oldVisual, startFrame: newStartFrame };
+      doc = {
+        ...doc,
+        layers: doc.layers.map((l) => l.id === layerId ? { ...l, visual: newVisual } : l)
+      };
+      doc = recomputeTimeline(doc);
+      const endFrame = clipEndFrame(newVisual, doc.canvas.fps);
+      persistDoc(store, documentId, doc, compositionPath);
+      return ok23({ layerId, oldStartFrame, newStartFrame, endFrame });
+    }
+  );
+  server.tool(
+    "atelier_trim_clip",
+    "Adjust a clip's sourceOffset / sourceEnd (in seconds). Captions outside the new effective range are not auto-pruned \u2014 the renderer skips out-of-range deltas.",
+    {
+      documentId: z48.string().describe("In-memory document ID to reload after disk write"),
+      projectDir: z48.string().describe("Absolute path to the project root"),
+      layerId: z48.string().describe("Layer id of the clip to trim"),
+      sourceOffset: z48.number().nonnegative().optional().describe("New seconds-into-source start"),
+      sourceEnd: z48.number().positive().optional().describe("New seconds-into-source end")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, projectDir, layerId, sourceOffset, sourceEnd }) => {
+      if (sourceOffset === void 0 && sourceEnd === void 0) {
+        return err23("at least one of sourceOffset / sourceEnd must be provided");
+      }
+      const loaded = loadDocFromDisk(projectDir);
+      if ("error" in loaded) return err23(loaded.error);
+      let { doc } = loaded;
+      const { compositionPath } = loaded;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err23(`clip layer "${layerId}" not found`);
+      if (layer.visual.type !== "video" && layer.visual.type !== "audio") {
+        return err23(`layer "${layerId}" is type "${layer.visual.type}", not a clip`);
+      }
+      const oldVisual = layer.visual;
+      const newVisual = { ...oldVisual };
+      if (sourceOffset !== void 0) newVisual.sourceOffset = sourceOffset;
+      if (sourceEnd !== void 0) newVisual.sourceEnd = sourceEnd;
+      doc = {
+        ...doc,
+        layers: doc.layers.map((l) => l.id === layerId ? { ...l, visual: newVisual } : l)
+      };
+      doc = recomputeTimeline(doc);
+      persistDoc(store, documentId, doc, compositionPath);
+      return ok23({
+        layerId,
+        sourceOffset: newVisual.sourceOffset ?? 0,
+        sourceEnd: newVisual.sourceEnd,
+        startFrame: newVisual.startFrame ?? 0,
+        endFrame: clipEndFrame(newVisual, doc.canvas.fps)
+      });
+    }
+  );
+  server.tool(
+    "atelier_remove_clip",
+    "Remove a clip layer plus all transitively-parented descendants (e.g. its caption layers) and any deltas referencing them. Refuses to remove a track group layer.",
+    {
+      documentId: z48.string().describe("In-memory document ID to reload after disk write"),
+      projectDir: z48.string().describe("Absolute path to the project root"),
+      layerId: z48.string().describe("Layer id of the clip to remove")
+    },
+    { readOnlyHint: false, destructiveHint: true },
+    async ({ documentId, projectDir, layerId }) => {
+      const loaded = loadDocFromDisk(projectDir);
+      if ("error" in loaded) return err23(loaded.error);
+      let { doc } = loaded;
+      const { compositionPath } = loaded;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err23(`layer "${layerId}" not found`);
+      if ((layer.tags ?? []).includes("track")) {
+        return err23("Cannot remove track group; use atelier_remove_track (not implemented in v1)");
+      }
+      const toRemove = /* @__PURE__ */ new Set([layerId]);
+      let grew = true;
+      while (grew) {
+        grew = false;
+        for (const l of doc.layers) {
+          if (toRemove.has(l.id)) continue;
+          if (l.parentId && toRemove.has(l.parentId)) {
+            toRemove.add(l.id);
+            grew = true;
+          }
+        }
+      }
+      const remainingLayers = doc.layers.filter((l) => !toRemove.has(l.id));
+      const newStates = {};
+      for (const [name, st] of Object.entries(doc.states)) {
+        newStates[name] = {
+          ...st,
+          deltas: st.deltas.filter((d) => !toRemove.has(d.layer))
+        };
+      }
+      const assets = { ...doc.assets ?? {} };
+      for (const id of toRemove) delete assets[id];
+      if (Object.keys(assets).length === 0) {
+        const { assets: _omit, ...rest } = doc;
+        void _omit;
+        doc = { ...rest, layers: remainingLayers, states: newStates };
+      } else {
+        doc = { ...doc, layers: remainingLayers, states: newStates, assets };
+      }
+      doc = recomputeTimeline(doc);
+      persistDoc(store, documentId, doc, compositionPath);
+      return ok23({
+        layerId,
+        removedLayerIds: Array.from(toRemove),
+        removedCount: toRemove.size
+      });
+    }
+  );
+  server.tool(
+    "atelier_transcribe_clip",
+    "Run transcription on a clip's source media and (re)build parented caption layers. Audio-layer captions are not supported in v1. Requires a transcribeFn injected via __setTranscribeClipFn (tests) or a pre-existing transcript at <projectDir>/transcripts/<stem>.json.",
+    {
+      documentId: z48.string().describe("In-memory document ID to reload after disk write"),
+      projectDir: z48.string().describe("Absolute path to the project root"),
+      layerId: z48.string().describe("Video clip layer id"),
+      model: z48.string().optional().describe("Whisper model selection forwarded to the injected transcribeFn")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, projectDir, layerId, model }) => {
+      const loaded = loadDocFromDisk(projectDir);
+      if ("error" in loaded) return err23(loaded.error);
+      let { doc } = loaded;
+      const { compositionPath } = loaded;
+      const layer = doc.layers.find((l) => l.id === layerId);
+      if (!layer) return err23(`clip layer "${layerId}" not found`);
+      if (layer.visual.type === "audio") {
+        return err23("audio layer captions are not supported in v1");
+      }
+      if (layer.visual.type !== "video") {
+        return err23(`layer "${layerId}" is type "${layer.visual.type}", not a video clip`);
+      }
+      const v = layer.visual;
+      const srcRef = v.src;
+      if (!srcRef) return err23(`video layer "${layerId}" has no src`);
+      const mediaBasename = basename4(srcRef);
+      let transcript;
+      let transcriptPath;
+      if (injectedTranscribeFn) {
+        const result = await injectedTranscribeFn({
+          projectDir,
+          mediaBasename,
+          ...model !== void 0 ? { model } : {}
+        });
+        transcript = result.transcript;
+        transcriptPath = result.transcriptPath;
+      } else {
+        const stem = stripExt2(mediaBasename);
+        const candidate = join6(resolve6(projectDir), "transcripts", `${stem}.json`);
+        if (!existsSync6(candidate)) {
+          return err23(
+            `no transcribeFn injected and no transcript mirror at ${candidate}. Install a host-provided transcribeFn via __setTranscribeClipFn or pre-write the transcript.`
+          );
+        }
+        try {
+          transcript = JSON.parse(readFileSync4(candidate, "utf-8"));
+          transcriptPath = candidate;
+        } catch (e) {
+          return err23(`failed to read transcript at ${candidate}: ${e.message}`);
+        }
+      }
+      if (!transcript) return err23("transcribeFn returned no transcript");
+      doc = rebuildClipCaptions(doc, layerId, transcript, doc.canvas);
+      doc = recomputeTimeline(doc);
+      const captionCount = doc.layers.filter(
+        (l) => l.parentId === layerId && (l.tags ?? []).includes("caption")
+      ).length;
+      persistDoc(store, documentId, doc, compositionPath);
+      return ok23({
+        layerId,
+        transcriptPath: transcriptPath ?? null,
+        captionCount
+      });
+    }
+  );
+  server.tool(
+    "atelier_move_slide",
+    "Reorder a carousel project's slides[] array. Refuses on non-carousel projects.",
+    {
+      documentId: z48.string().describe("In-memory document ID to reload after disk write"),
+      projectDir: z48.string().describe("Absolute path to the project root"),
+      fromIndex: z48.number().int().nonnegative().describe("Current index in slides[]"),
+      toIndex: z48.number().int().nonnegative().describe("Target index in slides[]")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, projectDir, fromIndex, toIndex }) => {
+      const loaded = loadDocFromDisk(projectDir);
+      if ("error" in loaded) return err23(loaded.error);
+      let { doc } = loaded;
+      const { compositionPath } = loaded;
+      if (doc.kind !== "carousel") {
+        return err23(`project kind is "${doc.kind ?? "video"}", not "carousel"`);
+      }
+      const slides = [...doc.slides ?? []];
+      if (fromIndex >= slides.length) {
+        return err23(`fromIndex ${fromIndex} out of bounds (slides.length=${slides.length})`);
+      }
+      if (toIndex >= slides.length) {
+        return err23(`toIndex ${toIndex} out of bounds (slides.length=${slides.length})`);
+      }
+      const [moved] = slides.splice(fromIndex, 1);
+      slides.splice(toIndex, 0, moved);
+      doc = { ...doc, slides };
+      persistDoc(store, documentId, doc, compositionPath);
+      return ok23({ slides });
+    }
+  );
+}
+function stripExt2(name) {
+  const ext = extname4(name);
+  return ext ? name.slice(0, -ext.length) : name;
+}
+
+// ../mcp/src/tools/rename-media.ts
+import { z as z49 } from "zod";
+
+// ../mcp/src/lib/rename-media.ts
+import {
+  existsSync as existsSync7,
+  readFileSync as readFileSync5,
+  renameSync,
+  writeFileSync as writeFileSync4
+} from "fs";
+import { extname as extname5, join as join7, resolve as resolve7 } from "path";
+var renameLocks = /* @__PURE__ */ new Map();
+function readAtelierDoc(absPath) {
+  const raw = readFileSync5(absPath, "utf-8");
+  const parsed = parseAtelier(raw);
+  if (parsed.success) return parsed.data;
+  return JSON.parse(raw);
+}
+function stripExt3(name) {
+  const ext = extname5(name);
+  return ext ? name.slice(0, -ext.length) : name;
+}
+function srcReferencesBasename(src, oldBasename) {
+  if (typeof src !== "string" || src.length === 0) return false;
+  if (src === oldBasename) return true;
+  if (src === `media/${oldBasename}`) return true;
+  if (src.endsWith(`/${oldBasename}`)) return true;
+  return false;
+}
+function rewriteSrc(src, oldBasename, newBasename) {
+  if (src === oldBasename) return newBasename;
+  if (src === `media/${oldBasename}`) return `media/${newBasename}`;
+  if (src.endsWith(`/${oldBasename}`)) {
+    return src.slice(0, -oldBasename.length) + newBasename;
+  }
+  return src;
+}
+function applyMediaRenameToDoc(doc, oldBasename, newBasename) {
+  const assetKeysUpdated = [];
+  const layersUpdated = [];
+  let newAssets = void 0;
+  if (doc.assets && typeof doc.assets === "object") {
+    const out2 = {};
+    for (const [key, asset] of Object.entries(doc.assets)) {
+      if (asset && typeof asset === "object" && srcReferencesBasename(asset.src, oldBasename)) {
+        out2[key] = { ...asset, src: rewriteSrc(asset.src, oldBasename, newBasename) };
+        assetKeysUpdated.push(key);
+      } else {
+        out2[key] = asset;
+      }
+    }
+    newAssets = out2;
+  }
+  const newLayers = doc.layers.map((layer) => {
+    const v = layer.visual;
+    if (!v || v.type !== "video" && v.type !== "audio" && v.type !== "image") {
+      return layer;
+    }
+    const visualWithSrc = v;
+    if (!srcReferencesBasename(visualWithSrc.src, oldBasename)) return layer;
+    layersUpdated.push(layer.id);
+    return {
+      ...layer,
+      visual: {
+        ...v,
+        src: rewriteSrc(visualWithSrc.src, oldBasename, newBasename)
+      }
+    };
+  });
+  const out = { ...doc, layers: newLayers };
+  if (newAssets !== void 0) out.assets = newAssets;
+  return { doc: out, assetKeysUpdated, layersUpdated };
+}
+function scanArtifactsForOldBasename(projectDir, oldBasename) {
+  const warnings = [];
+  const artifactFiles = ["DESIGN.md", "SCRIPT.md", "STORYBOARD.md"];
+  for (const name of artifactFiles) {
+    const absPath = join7(projectDir, name);
+    if (!existsSync7(absPath)) continue;
+    try {
+      const raw = readFileSync5(absPath, "utf-8");
+      if (raw.includes(oldBasename)) {
+        warnings.push(`${name} references old path '${oldBasename}'`);
+      }
+    } catch {
+    }
+  }
+  return warnings;
+}
+async function renameMedia(opts) {
+  const projectDir = resolve7(opts.projectDir);
+  const oldBasename = opts.oldBasename;
+  const newBasename = opts.newBasename;
+  if (oldBasename === newBasename) {
+    return {
+      docUpdated: false,
+      transcriptRenamed: false,
+      assetKeysUpdated: [],
+      layersUpdated: [],
+      timelineRegenerated: false,
+      warnings: []
+    };
+  }
+  const lockKey = projectDir;
+  const prev = renameLocks.get(lockKey) ?? Promise.resolve();
+  const run = prev.catch(() => {
+  }).then(() => renameMediaImpl(projectDir, oldBasename, newBasename, opts.dryRun));
+  renameLocks.set(lockKey, run);
+  try {
+    return await run;
+  } finally {
+    if (renameLocks.get(lockKey) === run) renameLocks.delete(lockKey);
+  }
+}
+async function renameMediaImpl(projectDir, oldBasename, newBasename, dryRun) {
+  const mediaDir = join7(projectDir, "media");
+  if (!existsSync7(mediaDir)) {
+    throw new Error(`renameMedia: project has no media/ dir at ${mediaDir}`);
+  }
+  const mediaOldAbs = join7(mediaDir, oldBasename);
+  const mediaNewAbs = join7(mediaDir, newBasename);
+  if (!existsSync7(mediaOldAbs)) {
+    throw new Error(`renameMedia: media file not found: ${mediaOldAbs}`);
+  }
+  if (existsSync7(mediaNewAbs)) {
+    throw new Error(`renameMedia: destination file already exists: ${mediaNewAbs}`);
+  }
+  const transcriptsDir = join7(projectDir, "transcripts");
+  const transcriptOldAbs = join7(transcriptsDir, `${stripExt3(oldBasename)}.json`);
+  const transcriptNewAbs = join7(transcriptsDir, `${stripExt3(newBasename)}.json`);
+  const transcriptExists = existsSync7(transcriptOldAbs);
+  const docPath = join7(projectDir, "project.atelier");
+  if (!existsSync7(docPath)) {
+    throw new Error(`renameMedia: missing project.atelier at ${docPath}`);
+  }
+  const originalDoc = readAtelierDoc(docPath);
+  const walked = applyMediaRenameToDoc(originalDoc, oldBasename, newBasename);
+  const hadTimeline = originalDoc.timeline !== void 0;
+  const newDoc = recomputeTimeline(walked.doc);
+  const hasTimelineAfter = newDoc.timeline !== void 0;
+  const timelineRegenerated = hadTimeline || hasTimelineAfter;
+  const warnings = scanArtifactsForOldBasename(projectDir, oldBasename);
+  if (dryRun === true) {
+    return {
+      docUpdated: false,
+      transcriptRenamed: false,
+      assetKeysUpdated: walked.assetKeysUpdated,
+      layersUpdated: walked.layersUpdated,
+      timelineRegenerated: false,
+      warnings
+    };
+  }
+  let mediaRenamed = false;
+  try {
+    renameSync(mediaOldAbs, mediaNewAbs);
+    mediaRenamed = true;
+  } catch (err24) {
+    throw new Error(
+      `renameMedia: failed to rename media file: ${err24 instanceof Error ? err24.message : String(err24)}`
+    );
+  }
+  let transcriptRenamed = false;
+  if (transcriptExists) {
+    try {
+      renameSync(transcriptOldAbs, transcriptNewAbs);
+      transcriptRenamed = true;
+    } catch (err24) {
+      try {
+        renameSync(mediaNewAbs, mediaOldAbs);
+      } catch (rbErr) {
+        console.error(
+          `renameMedia: CRITICAL \u2014 rollback of media rename failed: ${rbErr instanceof Error ? rbErr.message : String(rbErr)}`
+        );
+      }
+      throw new Error(
+        `renameMedia: failed to rename transcript: ${err24 instanceof Error ? err24.message : String(err24)}`
+      );
+    }
+  }
+  try {
+    writeFileSync4(docPath, JSON.stringify(newDoc, null, 2), "utf-8");
+  } catch (err24) {
+    if (transcriptRenamed) {
+      try {
+        renameSync(transcriptNewAbs, transcriptOldAbs);
+      } catch (rbErr) {
+        console.error(
+          `renameMedia: CRITICAL \u2014 rollback of transcript rename failed: ${rbErr instanceof Error ? rbErr.message : String(rbErr)}`
+        );
+      }
+    }
+    if (mediaRenamed) {
+      try {
+        renameSync(mediaNewAbs, mediaOldAbs);
+      } catch (rbErr) {
+        console.error(
+          `renameMedia: CRITICAL \u2014 rollback of media rename failed: ${rbErr instanceof Error ? rbErr.message : String(rbErr)}`
+        );
+      }
+    }
+    throw new Error(
+      `renameMedia: failed to write project.atelier: ${err24 instanceof Error ? err24.message : String(err24)}`
+    );
+  }
+  return {
+    docUpdated: true,
+    transcriptRenamed,
+    assetKeysUpdated: walked.assetKeysUpdated,
+    layersUpdated: walked.layersUpdated,
+    timelineRegenerated,
+    warnings
+  };
+}
+function isValidMediaBasenameForRename(name) {
+  if (typeof name !== "string") return false;
+  if (name.length === 0) return false;
+  if (name !== name.trim()) return false;
+  if (name.includes("/") || name.includes("\\")) return false;
+  if (name === "." || name === "..") return false;
+  if (name.startsWith(".")) return false;
+  if (/[\x00-\x1f]/.test(name)) return false;
+  return true;
+}
+
+// ../mcp/src/tools/rename-media.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { join as join8, resolve as resolve8, sep } from "path";
+function register24(server, store) {
+  server.tool(
+    "atelier_rename_media",
+    "Rename a media file in a project, cascading the rename through transcripts and the project document. Atomic with rollback on partial failure.",
+    {
+      documentId: z49.string().describe("Document ID"),
+      projectDir: z49.string().describe("Absolute project directory path"),
+      oldBasename: z49.string().describe("Current basename inside media/, e.g. 'IMG_7346.MOV'"),
+      newBasename: z49.string().describe("New basename inside media/"),
+      dryRun: z49.boolean().optional().describe("If true, compute the result without writing"),
+      workspaceDir: z49.string().optional().describe("Workspace root for security scoping (defaults to process.cwd())")
+    },
+    { readOnlyHint: false, destructiveHint: true },
+    async ({ documentId, projectDir, oldBasename, newBasename, dryRun, workspaceDir }) => {
+      try {
+        if (!isValidMediaBasenameForRename(oldBasename)) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "invalid oldBasename" }) }],
+            isError: true
+          };
+        }
+        if (!isValidMediaBasenameForRename(newBasename)) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "invalid newBasename" }) }],
+            isError: true
+          };
+        }
+        const workspaceRoot = resolve8(workspaceDir ?? process.cwd());
+        const resolvedProject = resolve8(projectDir);
+        if (resolvedProject !== workspaceRoot && !resolvedProject.startsWith(workspaceRoot + sep)) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `projectDir must be inside workspace ${workspaceRoot}` }) }],
+            isError: true
+          };
+        }
+        if (!existsSync8(join8(resolvedProject, "project.atelier"))) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "projectDir does not contain project.atelier" }) }],
+            isError: true
+          };
+        }
+        const result = await renameMedia({
+          projectDir: resolvedProject,
+          oldBasename,
+          newBasename,
+          ...dryRun !== void 0 ? { dryRun } : {}
+        });
+        if (!dryRun) {
+          const docPath = join8(resolvedProject, "project.atelier");
+          const raw = readFileSync6(docPath, "utf-8");
+          const parsed = parseAtelier(raw);
+          if (parsed.success) {
+            store.set(documentId, parsed.data, "system");
+          }
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify({ success: true, result }) }]
+        };
+      } catch (e) {
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: e.message }) }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp/src/tools/docs.ts
+import { z as z50 } from "zod";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join10, resolve as resolve10, sep as sep2 } from "path";
+
+// ../mcp/src/lib/doc-management.ts
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync7,
+  statSync as statSync5,
+  unlinkSync,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { basename as basename5, dirname as dirname2, extname as extname6, isAbsolute as isAbsolute3, join as join9, relative, resolve as resolve9 } from "path";
+
+// ../mcp/src/lib/doc-management-types.ts
+function isValidDocName(name) {
+  if (typeof name !== "string") return false;
+  const trimmed = name.trim();
+  if (trimmed.length === 0) return false;
+  if (trimmed.length > 200) return false;
+  if (trimmed.startsWith(".")) return false;
+  if (trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("..")) return false;
+  if (/[\x00-\x1f]/.test(trimmed)) return false;
+  return true;
+}
+
+// ../mcp/src/lib/doc-management.ts
+function slugifyBasename2(name) {
+  const noExt = name.replace(/\.[^.]+$/, "");
+  const slugged = noExt.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slugged;
+}
+function readAtelierDoc2(absPath) {
+  const raw = readFileSync7(absPath, "utf-8");
+  const parsed = parseAtelier(raw);
+  if (parsed.success) return parsed.data;
+  return JSON.parse(raw);
+}
+function scaffoldDoc(slug, kind) {
+  const base = {
+    version: "1.0",
+    name: slug,
+    kind,
+    canvas: { width: 1080, height: 1920, fps: 30 },
+    layers: [],
+    states: { default: { duration: 1, deltas: [] } }
+  };
+  if (kind === "carousel") {
+    base.slides = [];
+  }
+  return base;
+}
+function createDoc(opts) {
+  if (!isValidDocName(opts.name)) {
+    throw new Error("invalid doc name");
+  }
+  const projectDir = resolve9(opts.projectDir);
+  const slug = slugifyBasename2(opts.name);
+  if (slug.length === 0) {
+    throw new Error("invalid doc name");
+  }
+  const subdir = opts.asCarouselSlide ? "slides" : "";
+  const baseDir = subdir ? join9(projectDir, subdir) : projectDir;
+  let finalStem = slug;
+  let attempt = 0;
+  while (existsSync9(join9(baseDir, `${finalStem}.atelier`))) {
+    attempt += 1;
+    if (attempt > 999) {
+      throw new Error(`createDoc: could not find a non-colliding stem for "${slug}"`);
+    }
+    finalStem = `${slug}-${attempt}`;
+  }
+  const newDocAbsPath = join9(baseDir, `${finalStem}.atelier`);
+  const newDocPath = subdir ? `${subdir}/${finalStem}.atelier` : `${finalStem}.atelier`;
+  const newDoc = scaffoldDoc(finalStem, opts.kind);
+  mkdirSync2(dirname2(newDocAbsPath), { recursive: true });
+  writeFileSync5(newDocAbsPath, JSON.stringify(newDoc, null, 2), "utf-8");
+  if (opts.asCarouselSlide) {
+    if (!opts.carouselDocPath) {
+      throw new Error("createDoc: asCarouselSlide requires carouselDocPath");
+    }
+    const carouselAbs = resolve9(opts.carouselDocPath);
+    if (!existsSync9(carouselAbs)) {
+      throw new Error(`createDoc: carouselDocPath does not exist: ${carouselAbs}`);
+    }
+    const carouselDoc = readAtelierDoc2(carouselAbs);
+    if (carouselDoc.kind !== "carousel") {
+      throw new Error(`createDoc: carouselDocPath is not a carousel doc (kind=${carouselDoc.kind ?? "video"})`);
+    }
+    const slideSrc = relative(projectDir, newDocAbsPath).split("\\").join("/");
+    const slides = carouselDoc.slides ?? [];
+    if (slides.some((s) => s.src === slideSrc)) {
+      try {
+        unlinkSync(newDocAbsPath);
+      } catch {
+      }
+      throw new Error(`createDoc: slide ${slideSrc} already exists in carousel`);
+    }
+    const insertAt = typeof opts.insertAt === "number" && opts.insertAt >= 0 && opts.insertAt <= slides.length ? opts.insertAt : slides.length;
+    const newSlide = { src: slideSrc };
+    const newSlides = [...slides.slice(0, insertAt), newSlide, ...slides.slice(insertAt)];
+    const updatedCarousel = { ...carouselDoc, slides: newSlides };
+    writeFileSync5(carouselAbs, JSON.stringify(updatedCarousel, null, 2), "utf-8");
+    return { newDocPath, newDocAbsPath, appendedSlideIndex: insertAt };
+  }
+  return { newDocPath, newDocAbsPath };
+}
+function duplicateDoc(opts) {
+  const projectDir = resolve9(opts.projectDir);
+  const sourceAbs = join9(projectDir, opts.sourceDocPath);
+  if (!existsSync9(sourceAbs)) {
+    throw new Error(`duplicateDoc: source doc not found: ${opts.sourceDocPath}`);
+  }
+  const sourceDoc = readAtelierDoc2(sourceAbs);
+  const sourceDir = dirname2(sourceAbs);
+  const sourceBase = basename5(sourceAbs);
+  const sourceExt = extname6(sourceBase);
+  const sourceStem = sourceExt ? sourceBase.slice(0, -sourceExt.length) : sourceBase;
+  let finalStem;
+  for (let attempt = 1; attempt <= 999; attempt++) {
+    const candidate = attempt === 1 ? `${sourceStem}-copy` : `${sourceStem}-copy-${attempt}`;
+    if (!existsSync9(join9(sourceDir, `${candidate}.atelier`))) {
+      finalStem = candidate;
+      break;
+    }
+  }
+  if (!finalStem) {
+    throw new Error(`duplicateDoc: could not find a non-colliding stem for "${sourceStem}-copy"`);
+  }
+  const newDocAbsPath = join9(sourceDir, `${finalStem}.atelier`);
+  const sourceRel = opts.sourceDocPath;
+  const lastSlash = sourceRel.lastIndexOf("/");
+  const parentRel = lastSlash >= 0 ? sourceRel.slice(0, lastSlash + 1) : "";
+  const newDocPath = `${parentRel}${finalStem}.atelier`;
+  const dupDoc = { ...sourceDoc };
+  writeFileSync5(newDocAbsPath, JSON.stringify(dupDoc, null, 2), "utf-8");
+  const report = {
+    sourceDocPath: opts.sourceDocPath,
+    newDocPath
+  };
+  if (opts.appendSlideRef) {
+    const sourceDirRel = dirname2(opts.sourceDocPath);
+    if (sourceDirRel !== "slides") {
+      try {
+        unlinkSync(newDocAbsPath);
+      } catch {
+      }
+      throw new Error("appendSlideRef requires a slide source");
+    }
+    const manifestAbs = join9(projectDir, "project.atelier");
+    if (!existsSync9(manifestAbs)) {
+      throw new Error("duplicateDoc: appendSlideRef requested but project.atelier is missing");
+    }
+    const manifest = readAtelierDoc2(manifestAbs);
+    if (manifest.kind !== "carousel") {
+      throw new Error(`duplicateDoc: appendSlideRef requires a carousel manifest (kind=${manifest.kind ?? "video"})`);
+    }
+    const slideSrc = relative(projectDir, newDocAbsPath).split("\\").join("/");
+    const slides = manifest.slides ?? [];
+    if (slides.some((s) => s.src === slideSrc)) {
+      throw new Error(`duplicateDoc: slide ${slideSrc} already exists in carousel`);
+    }
+    const sourceSlideSrc = relative(projectDir, sourceAbs).split("\\").join("/");
+    const sourceIndex = slides.findIndex((s) => s.src === sourceSlideSrc);
+    const insertAt = sourceIndex >= 0 ? sourceIndex + 1 : slides.length;
+    const newSlide = { src: slideSrc };
+    const newSlides = [...slides.slice(0, insertAt), newSlide, ...slides.slice(insertAt)];
+    const updatedManifest = { ...manifest, slides: newSlides };
+    writeFileSync5(manifestAbs, JSON.stringify(updatedManifest, null, 2), "utf-8");
+    report.appendedSlideIndex = insertAt;
+  }
+  return report;
+}
+function deleteDoc(opts) {
+  const workspaceDir = resolve9(opts.workspaceDir);
+  const projectDir = join9(workspaceDir, opts.projectName);
+  const docAbs = join9(projectDir, opts.docPath);
+  if (!existsSync9(docAbs)) {
+    throw new Error(`deleteDoc: doc not found: ${opts.docPath}`);
+  }
+  const report = {
+    docPath: opts.docPath,
+    slideRefsRemoved: [],
+    refLayersDangling: []
+  };
+  let projectNames = [];
+  try {
+    projectNames = readdirSync5(workspaceDir).filter((entry) => {
+      if (entry.startsWith(".")) return false;
+      try {
+        const projDir = join9(workspaceDir, entry);
+        if (!statSync5(projDir).isDirectory()) return false;
+        return existsSync9(join9(projDir, "project.atelier"));
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    projectNames = [];
+  }
+  for (const projName of projectNames) {
+    const projDir = join9(workspaceDir, projName);
+    const projectAtelierFiles = listAtelierFilesUnderProject(projDir);
+    for (const atelierAbs of projectAtelierFiles) {
+      let doc;
+      try {
+        doc = readAtelierDoc2(atelierAbs);
+      } catch {
+        continue;
+      }
+      let mutated = false;
+      const docRel = relative(projDir, atelierAbs).split("\\").join("/");
+      if (doc.kind === "carousel" && Array.isArray(doc.slides)) {
+        const keptSlides = [];
+        doc.slides.forEach((slide, idx) => {
+          const slideAbs = resolveRefSrc(slide.src, atelierAbs, projDir, workspaceDir);
+          if (slideAbs === docAbs) {
+            report.slideRefsRemoved.push({ project: projName, slideIndex: idx });
+            mutated = true;
+            return;
+          }
+          keptSlides.push(slide);
+        });
+        if (mutated) {
+          doc = { ...doc, slides: keptSlides };
+        }
+      }
+      if (Array.isArray(doc.layers)) {
+        for (const layer of doc.layers) {
+          const v = layer.visual;
+          if (!v || v.type !== "ref") continue;
+          const refV = v;
+          if (typeof refV.src !== "string" || !refV.src) continue;
+          const refAbs = resolveRefSrc(refV.src, atelierAbs, projDir, workspaceDir);
+          if (refAbs === docAbs) {
+            report.refLayersDangling.push({
+              project: projName,
+              docPath: docRel,
+              layerId: layer.id
+            });
+          }
+        }
+      }
+      if (mutated) {
+        writeFileSync5(atelierAbs, JSON.stringify(doc, null, 2), "utf-8");
+      }
+    }
+  }
+  unlinkSync(docAbs);
+  return report;
+}
+function listAtelierFilesUnderProject(projectDir) {
+  const out = [];
+  try {
+    for (const entry of readdirSync5(projectDir)) {
+      if (entry === ".atelier") continue;
+      if (!entry.endsWith(".atelier")) continue;
+      const abs = join9(projectDir, entry);
+      try {
+        if (statSync5(abs).isFile()) out.push(abs);
+      } catch {
+      }
+    }
+  } catch {
+  }
+  const slidesDir = join9(projectDir, "slides");
+  if (existsSync9(slidesDir)) {
+    try {
+      for (const entry of readdirSync5(slidesDir)) {
+        if (!entry.endsWith(".atelier")) continue;
+        const abs = join9(slidesDir, entry);
+        try {
+          if (statSync5(abs).isFile()) out.push(abs);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+function resolveRefSrc(src, currentDocAbs, ownerProjectDir, workspaceRoot) {
+  if (isAbsolute3(src)) {
+    return existsSync9(src) ? resolve9(src) : void 0;
+  }
+  const projectRelative = resolve9(ownerProjectDir, src);
+  if (existsSync9(projectRelative)) return projectRelative;
+  const docRelative = resolve9(dirname2(currentDocAbs), src);
+  if (existsSync9(docRelative)) return docRelative;
+  const workspaceRelative = resolve9(workspaceRoot, src);
+  if (existsSync9(workspaceRelative)) return workspaceRelative;
+  return void 0;
+}
+function listDocs(projectDir) {
+  const projAbs = resolve9(projectDir);
+  const collected = [];
+  try {
+    for (const entry of readdirSync5(projAbs)) {
+      if (entry === ".atelier") continue;
+      if (!entry.endsWith(".atelier")) continue;
+      const abs = join9(projAbs, entry);
+      try {
+        if (!statSync5(abs).isFile()) continue;
+      } catch {
+        continue;
+      }
+      collected.push({ rel: entry, abs });
+    }
+  } catch {
+  }
+  const slidesDir = join9(projAbs, "slides");
+  if (existsSync9(slidesDir)) {
+    try {
+      for (const entry of readdirSync5(slidesDir)) {
+        if (!entry.endsWith(".atelier")) continue;
+        const abs = join9(slidesDir, entry);
+        try {
+          if (!statSync5(abs).isFile()) continue;
+        } catch {
+          continue;
+        }
+        collected.push({ rel: `slides/${entry}`, abs });
+      }
+    } catch {
+    }
+  }
+  collected.sort((a, b) => a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0);
+  const out = [];
+  for (const { rel, abs } of collected) {
+    let kind;
+    try {
+      kind = readAtelierDoc2(abs).kind;
+    } catch {
+    }
+    const entry = { path: rel };
+    if (kind !== void 0) entry.kind = kind;
+    out.push(entry);
+  }
+  return out;
+}
+
+// ../mcp/src/tools/docs.ts
+function errorEnvelope(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+function successEnvelope(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ success: true, ...payload }) }]
+  };
+}
+function resolveProjectInWorkspace(projectDir, workspaceDir) {
+  const workspaceAbs = resolve10(workspaceDir ?? process.cwd());
+  const projectAbs = resolve10(projectDir);
+  if (projectAbs !== workspaceAbs && !projectAbs.startsWith(workspaceAbs + sep2)) {
+    return { ok: false, error: `projectDir must be inside workspace ${workspaceAbs}` };
+  }
+  return { ok: true, workspaceAbs, projectAbs };
+}
+function readDocFromDisk(absPath) {
+  try {
+    const raw = readFileSync8(absPath, "utf-8");
+    const parsed = parseAtelier(raw);
+    if (parsed.success) return parsed.data;
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function register25(server, store) {
+  server.tool(
+    "atelier_create_doc",
+    "Create a new .atelier doc inside a workspace project. Optionally append it to a carousel's slides[].",
+    {
+      documentId: z50.string().describe("Document ID under which to reload the affected doc"),
+      projectDir: z50.string().describe("Absolute project directory (must contain project.atelier)"),
+      workspaceDir: z50.string().optional().describe("Workspace root for security scoping (defaults to process.cwd())"),
+      name: z50.string().describe("Human-typed doc name; slugged internally to a filesystem-safe stem"),
+      kind: z50.enum(["video", "image", "carousel"]).describe("Doc kind"),
+      asCarouselSlide: z50.boolean().optional().describe("If true, write under slides/ and append a SlideRef to carouselDocPath"),
+      carouselDocPath: z50.string().optional().describe("Absolute path to the carousel doc whose slides[] to mutate (required when asCarouselSlide:true)"),
+      insertAt: z50.number().int().optional().describe("Index in carousel slides[] (default = append)")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, projectDir, workspaceDir, name, kind, asCarouselSlide, carouselDocPath, insertAt }) => {
+      try {
+        if (!isValidDocName(name)) return errorEnvelope("invalid doc name");
+        const scope = resolveProjectInWorkspace(projectDir, workspaceDir);
+        if (!scope.ok) return errorEnvelope(scope.error);
+        if (!existsSync10(join10(scope.projectAbs, "project.atelier"))) {
+          return errorEnvelope("projectDir does not contain project.atelier");
+        }
+        if (asCarouselSlide && carouselDocPath) {
+          const carouselAbs = resolve10(carouselDocPath);
+          if (carouselAbs !== scope.workspaceAbs && !carouselAbs.startsWith(scope.workspaceAbs + sep2)) {
+            return errorEnvelope(`carouselDocPath must be inside workspace ${scope.workspaceAbs}`);
+          }
+        }
+        const result = createDoc({
+          projectDir: scope.projectAbs,
+          name,
+          kind,
+          ...asCarouselSlide !== void 0 ? { asCarouselSlide } : {},
+          ...carouselDocPath !== void 0 ? { carouselDocPath } : {},
+          ...insertAt !== void 0 ? { insertAt } : {}
+        });
+        const reloadTarget = asCarouselSlide && carouselDocPath ? resolve10(carouselDocPath) : result.newDocAbsPath;
+        const doc = readDocFromDisk(reloadTarget);
+        if (doc) store.set(documentId, doc, "llm");
+        const payload = { docPath: result.newDocPath };
+        if (result.appendedSlideIndex !== void 0) {
+          payload.appendedSlideIndex = result.appendedSlideIndex;
+        }
+        return successEnvelope(payload);
+      } catch (e) {
+        return errorEnvelope(e.message);
+      }
+    }
+  );
+  server.tool(
+    "atelier_duplicate_doc",
+    "Duplicate an existing .atelier doc inside a project. Optionally appends a SlideRef to the project's carousel manifest (requires the source to live directly under slides/).",
+    {
+      documentId: z50.string().describe("Document ID under which to reload the affected doc"),
+      projectDir: z50.string().describe("Absolute project directory (must contain project.atelier)"),
+      workspaceDir: z50.string().optional().describe("Workspace root for security scoping (defaults to process.cwd())"),
+      sourceDocPath: z50.string().describe("Project-relative path of the doc to duplicate (e.g. 'slides/slide-1.atelier')"),
+      appendSlideRef: z50.boolean().optional().describe("If true, append a SlideRef pointing at the duplicate to the project manifest")
+    },
+    { readOnlyHint: false, destructiveHint: false },
+    async ({ documentId, projectDir, workspaceDir, sourceDocPath, appendSlideRef }) => {
+      try {
+        const scope = resolveProjectInWorkspace(projectDir, workspaceDir);
+        if (!scope.ok) return errorEnvelope(scope.error);
+        if (!existsSync10(join10(scope.projectAbs, "project.atelier"))) {
+          return errorEnvelope("projectDir does not contain project.atelier");
+        }
+        const report = duplicateDoc({
+          projectDir: scope.projectAbs,
+          sourceDocPath,
+          ...appendSlideRef !== void 0 ? { appendSlideRef } : {}
+        });
+        const reloadTarget = appendSlideRef ? join10(scope.projectAbs, "project.atelier") : join10(scope.projectAbs, report.newDocPath);
+        const doc = readDocFromDisk(reloadTarget);
+        if (doc) store.set(documentId, doc, "llm");
+        return successEnvelope(report);
+      } catch (e) {
+        return errorEnvelope(e.message);
+      }
+    }
+  );
+  server.tool(
+    "atelier_delete_doc",
+    "Delete any .atelier doc (including project.atelier), scrubbing matching SlideRefs across the workspace and reporting dangling RefVisual layers.",
+    {
+      documentId: z50.string().describe("Document ID \u2014 if equal to the deleted doc's path, the studio handles fallback"),
+      workspaceDir: z50.string().optional().describe("Workspace root for security scoping (defaults to process.cwd())"),
+      projectName: z50.string().describe("Project subdir name inside workspaceDir"),
+      docPath: z50.string().describe("Project-relative path of the doc to delete (e.g. 'slides/slide-2.atelier')")
+    },
+    { readOnlyHint: false, destructiveHint: true },
+    async ({ documentId: _documentId, workspaceDir, projectName, docPath }) => {
+      try {
+        const workspaceAbs = resolve10(workspaceDir ?? process.cwd());
+        const projectAbs = resolve10(join10(workspaceAbs, projectName));
+        if (projectAbs !== workspaceAbs && !projectAbs.startsWith(workspaceAbs + sep2)) {
+          return errorEnvelope(`projectName must resolve inside workspace ${workspaceAbs}`);
+        }
+        if (!existsSync10(join10(projectAbs, "project.atelier"))) {
+          return errorEnvelope("project does not contain project.atelier");
+        }
+        const report = deleteDoc({
+          workspaceDir: workspaceAbs,
+          projectName,
+          docPath
+        });
+        void _documentId;
+        return successEnvelope(report);
+      } catch (e) {
+        return errorEnvelope(e.message);
+      }
+    }
+  );
+  server.tool(
+    "atelier_list_docs",
+    "Enumerate every .atelier doc inside a project (flat alphabetical by project-relative path). Returns each as { path, kind? }.",
+    {
+      projectDir: z50.string().describe("Absolute project directory"),
+      workspaceDir: z50.string().optional().describe("Workspace root for security scoping (defaults to process.cwd())")
+    },
+    { readOnlyHint: true, destructiveHint: false },
+    async ({ projectDir, workspaceDir }) => {
+      try {
+        const scope = resolveProjectInWorkspace(projectDir, workspaceDir);
+        if (!scope.ok) return errorEnvelope(scope.error);
+        const docs = listDocs(scope.projectAbs);
+        return successEnvelope({ docs });
+      } catch (e) {
+        return errorEnvelope(e.message);
+      }
+    }
+  );
+}
+
 // ../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";
+  return t === "hello" || t === "doc:load" || t === "doc:loaded" || t === "doc:patch" || t === "llm:mutation" || t === "error" || t === "media:list:changed" || t === "transcript:added" || t === "media:ingest:progress" || t === "file:deleted" || t === "media:deleted" || t === "project:deleted" || t === "doc:list:changed";
 }
 
 // ../mcp/src/transports/ws-transport.ts
@@ -5302,17 +7681,17 @@ var WebSocketServerTransport = class {
         } else {
           text = String(data);
         }
-      } catch (err20) {
-        this.onerror?.(err20 instanceof Error ? err20 : new Error(String(err20)));
+      } catch (err24) {
+        this.onerror?.(err24 instanceof Error ? err24 : new Error(String(err24)));
         return;
       }
       let parsed;
       try {
         parsed = JSON.parse(text);
-      } catch (err20) {
+      } catch (err24) {
         this.onerror?.(
           new Error(
-            `WebSocketServerTransport: failed to parse JSON-RPC message: ${err20 instanceof Error ? err20.message : String(err20)}`
+            `WebSocketServerTransport: failed to parse JSON-RPC message: ${err24 instanceof Error ? err24.message : String(err24)}`
           )
         );
         return;
@@ -5324,8 +7703,8 @@ var WebSocketServerTransport = class {
       this.closed = true;
       this.onclose?.();
     });
-    this.ws.on("error", (err20) => {
-      this.onerror?.(err20);
+    this.ws.on("error", (err24) => {
+      this.onerror?.(err24);
     });
   }
   async send(message) {
@@ -5375,6 +7754,12 @@ function createServer(store = new DocumentStore()) {
   register17(server, store);
   register18(server, store);
   register19(server, store);
+  register20(server, store);
+  register21(server, store);
+  register22(server, store);
+  register23(server, store);
+  register24(server, store);
+  register25(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"));
@@ -5390,22 +7775,28 @@ export {
   BRIDGE_PROTOCOL_VERSION,
   DocumentStore,
   WebSocketServerTransport,
+  __setProbeDurationFn,
+  __setTranscribeClipFn,
   createServer,
   isBridgeEnvelope,
   register12 as registerAssetTools,
+  register23 as registerClipTools,
   register5 as registerDeltaTools,
+  register25 as registerDocTools,
   register as registerDocumentTools,
   register11 as registerExportTools,
   register19 as registerImportImageTools,
   register14 as registerInteractionTools,
   register9 as registerLayerEffectTools,
   register2 as registerLayerTools,
+  register20 as registerMindMapTools,
   register17 as registerOverlayTools,
   register16 as registerPerformanceTools,
   register6 as registerPresetTools,
   register7 as registerPreviewTools,
   register18 as registerRecipeTools,
   register15 as registerRefTools,
+  register24 as registerRenameMediaTool,
   register3 as registerShapeTools,
   register10 as registerStateConfigTools,
   register4 as registerStateTools,