@a-company/atelier 0.37.0 → 0.38.0

package/dist/index.cjs

@@ -409,12 +409,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;
         }
@@ -435,6 +438,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) {
@@ -1044,7 +1067,40 @@ function renderVideo(ctx, eff, sourceTime, provider) {
   if (!src) return;
   const frame = provider(src, sourceTime, eff.width, eff.height);
   if (!frame) return;
-  ctx.drawImage(frame, 0, 0, eff.width, eff.height);
+  const fit = visual.objectFit ?? "contain";
+  if (fit === "fill") {
+    ctx.drawImage(frame, 0, 0, eff.width, eff.height);
+    return;
+  }
+  const src_w = frame.videoWidth ?? frame.width ?? 0;
+  const src_h = frame.videoHeight ?? frame.height ?? 0;
+  if (src_w <= 0 || src_h <= 0) {
+    ctx.drawImage(frame, 0, 0, eff.width, eff.height);
+    return;
+  }
+  const srcAspect = src_w / src_h;
+  const dstAspect = eff.width / eff.height;
+  let dw, dh, dx, dy;
+  if (fit === "cover") {
+    if (srcAspect > dstAspect) {
+      dh = eff.height;
+      dw = dh * srcAspect;
+    } else {
+      dw = eff.width;
+      dh = dw / srcAspect;
+    }
+  } else {
+    if (srcAspect > dstAspect) {
+      dw = eff.width;
+      dh = dw / srcAspect;
+    } else {
+      dh = eff.height;
+      dw = dh * srcAspect;
+    }
+  }
+  dx = (eff.width - dw) / 2;
+  dy = (eff.height - dh) / 2;
+  ctx.drawImage(frame, dx, dy, dw, dh);
 }
 function renderRef(ctx, eff, opts, _parentDoc) {
   const visual = eff.visual;
@@ -1155,8 +1211,11 @@ function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
     maxRefDepth = opts.maxRefDepth ?? 4;
   }
   const { width, height } = doc.canvas;
-  ctx.fillStyle = doc.canvas.background ?? "transparent";
-  ctx.fillRect(0, 0, width, height);
+  ctx.clearRect(0, 0, width, height);
+  if (doc.canvas.background) {
+    ctx.fillStyle = doc.canvas.background;
+    ctx.fillRect(0, 0, width, height);
+  }
   const effMap = /* @__PURE__ */ new Map();
   const effList = [];
   const videoSourceTimeMap = /* @__PURE__ */ new Map();
@@ -1421,9 +1480,12 @@ var init_dist3 = __esm({
 });
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
+var src_exports = {};
+__export(src_exports, {
+  ARTIFACT_FILENAMES: () => ARTIFACT_FILENAMES,
   CanvasUnavailableError: () => CanvasUnavailableError,
+  LEARNING_MODES: () => LEARNING_MODES,
+  LEARNING_MODE_VERSION: () => LEARNING_MODE_VERSION,
   RECIPE_VERSION: () => RECIPE_VERSION,
   VIDEO_CUTLIST_VERSION: () => VIDEO_CUTLIST_VERSION,
   VIDEO_PROJECT_VERSION: () => VIDEO_PROJECT_VERSION,
@@ -1438,6 +1500,7 @@ __export(index_exports, {
   applyRecipeToTrimOptions: () => applyRecipeToTrimOptions,
   applySplit: () => applySplit,
   applyTextEdit: () => applyTextEdit,
+  artifactsCommand: () => artifactsCommand,
   assetsCommand: () => assetsCommand,
   buildCaptionLayers: () => buildCaptionLayers,
   buildFfmpegArgs: () => buildFfmpegArgs,
@@ -1445,8 +1508,15 @@ __export(index_exports, {
   carouselCommand: () => carouselCommand,
   carouselFileName: () => carouselFileName,
   checkFfmpeg: () => checkFfmpeg,
+  classifyMediaFile: () => classifyMediaFile,
   composeCarouselFrameDoc: () => composeCarouselFrameDoc,
+  composeCarouselProject: () => composeCarouselProject,
+  composeImageProject: () => composeImageProject,
+  composeVideoProject: () => composeVideoProject,
+  createDoc: () => createDoc,
   createVideoProject: () => createVideoProject,
+  deleteDoc: () => deleteDoc,
+  duplicateDoc: () => duplicateDoc,
   effectiveSpan: () => effectiveSpan,
   expandInputs: () => expandInputs,
   exportImageCommand: () => exportImageCommand,
@@ -1459,26 +1529,38 @@ __export(index_exports, {
   getVariables: () => getVariables,
   groupIntoPhrases: () => groupIntoPhrases,
   infoCommand: () => infoCommand,
+  initCommand: () => initCommand,
+  isInsideGitRepo: () => isInsideGitRepo,
+  isValidDocName: () => isValidDocName,
+  learningModePath: () => learningModePath,
+  listDocs: () => listDocs,
+  loadArtifactsFromProject: () => loadArtifactsFromProject,
   loadCanvasModule: () => loadCanvasModule,
   loadRecipe: () => loadRecipe,
   loadVideoProject: () => loadVideoProject,
   mergeTranscriptWithExisting: () => mergeTranscriptWithExisting,
+  parseModeAnswer: () => parseModeAnswer,
   parseWhisperCppJson: () => parseWhisperCppJson,
   probeWhisper: () => probeWhisper,
   readComposition: () => readComposition,
   readCutList: () => readCutList,
+  readLearningMode: () => readLearningMode,
   readTranscript: () => readTranscript,
   recipeCommand: () => recipeCommand,
   recipeToYaml: () => recipeToYaml,
   renderCommand: () => renderCommand,
   renderDocument: () => renderDocument,
   renderDocumentToPng: () => renderDocumentToPng,
+  renderLearningModeYaml: () => renderLearningModeYaml,
   renderRecipeWithDefaults: () => renderRecipeWithDefaults,
   resolveExportDimensions: () => resolveExportDimensions,
   resolveRecipePath: () => resolveRecipePath,
   resolveStill: () => resolveStill,
   rewriteCaptionLayers: () => rewriteCaptionLayers,
   rewriteCutLayers: () => rewriteCutLayers,
+  routeIngest: () => routeIngest,
+  routeIngestWithTarget: () => routeIngestWithTarget,
+  runInit: () => runInit,
   runWhisperCpp: () => runWhisperCpp,
   scaffoldRecipeYaml: () => scaffoldRecipeYaml,
   stillCommand: () => stillCommand,
@@ -1492,9 +1574,10 @@ __export(index_exports, {
   variablesCommand: () => variablesCommand,
   writeComposition: () => writeComposition,
   writeCutList: () => writeCutList,
+  writeLearningMode: () => writeLearningMode,
   writeTranscript: () => writeTranscript
 });
-module.exports = __toCommonJS(index_exports);
+module.exports = __toCommonJS(src_exports);
 
 // src/commands/validate.ts
 var import_node_fs = require("fs");
@@ -1516,7 +1599,18 @@ var import_zod12 = require("zod");
 var import_zod13 = require("zod");
 var import_zod14 = require("zod");
 var import_zod15 = require("zod");
+var import_zod16 = require("zod");
+var import_zod17 = require("zod");
+var import_zod18 = require("zod");
 var import_yaml = require("yaml");
+var import_zod19 = require("zod");
+var import_zod20 = require("zod");
+var import_zod21 = require("zod");
+var import_zod22 = require("zod");
+var import_zod23 = require("zod");
+var import_yaml2 = require("yaml");
+var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 var PixelSchema = import_zod.z.number();
 var PercentageSchema = import_zod.z.string().regex(/^-?\d+(\.\d+)?%$/, {
   message: 'Percentage must be a number followed by %, e.g. "50%"'
@@ -1769,6 +1863,19 @@ var VideoVisualSchema = import_zod7.z.object({
   muted: import_zod7.z.boolean().optional(),
   objectFit: import_zod7.z.enum(["contain", "cover", "fill"]).optional()
 });
+var AudioVisualSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("audio"),
+  assetId: import_zod7.z.string().min(1, "assetId is required"),
+  src: import_zod7.z.string().optional(),
+  startFrame: import_zod7.z.number().int().min(0).optional(),
+  sourceOffset: import_zod7.z.number().min(0).optional(),
+  sourceEnd: import_zod7.z.number().positive().optional(),
+  playbackRate: import_zod7.z.number().positive().optional(),
+  volume: import_zod7.z.number().min(0).max(1).optional(),
+  muted: import_zod7.z.boolean().optional(),
+  fadeIn: import_zod7.z.number().min(0).optional(),
+  fadeOut: import_zod7.z.number().min(0).optional()
+});
 var GroupVisualSchema = import_zod7.z.object({
   type: import_zod7.z.literal("group")
 });
@@ -1783,6 +1890,7 @@ var VisualSchema = import_zod7.z.discriminatedUnion("type", [
   TextVisualSchema,
   ImageVisualSchema,
   VideoVisualSchema,
+  AudioVisualSchema,
   GroupVisualSchema,
   RefVisualSchema
 ]);
@@ -1864,13 +1972,6 @@ var DeltaSchema = import_zod9.z.object({
   description: import_zod9.z.string().optional(),
   tags: import_zod9.z.array(import_zod9.z.string()).optional()
 });
-var AudioSchema = import_zod10.z.object({
-  src: import_zod10.z.string().min(1, "Audio src is required"),
-  offset: import_zod10.z.number().min(0, "Audio offset must be non-negative").optional(),
-  volume: import_zod10.z.number().min(0).max(1, "Audio volume must be 0\u20131").optional(),
-  loop: import_zod10.z.boolean().optional(),
-  startFrame: import_zod10.z.number().int().min(0, "Audio startFrame must be a non-negative integer").optional()
-});
 var StateTransitionConfigSchema = import_zod10.z.object({
   duration: import_zod10.z.number().int().positive("Transition duration must be a positive integer (frames)"),
   easing: EasingSchema.optional()
@@ -1881,7 +1982,6 @@ var StateSchema = import_zod10.z.object({
   parent: import_zod10.z.string().optional(),
   duration: import_zod10.z.number().int().positive("State duration must be a positive integer (frames)"),
   deltas: import_zod10.z.array(DeltaSchema),
-  audio: AudioSchema.optional(),
   transitions: import_zod10.z.record(import_zod10.z.string(), StateTransitionConfigSchema).optional()
 });
 var PresetDeltaSchema = import_zod11.z.object({
@@ -1921,61 +2021,119 @@ var AssetSchema = import_zod13.z.object({
     height: import_zod13.z.number().int().positive()
   }).optional()
 });
+var TimelineClipSchema = import_zod15.z.object({
+  layerId: import_zod15.z.string().min(1, "TimelineClip.layerId is required"),
+  startFrame: import_zod15.z.number().int().min(0, "startFrame must be a non-negative integer"),
+  endFrame: import_zod15.z.number().int().min(0, "endFrame must be a non-negative integer"),
+  source: import_zod15.z.string().min(1, "TimelineClip.source is required")
+});
+var TimelineTrackSchema = import_zod15.z.object({
+  id: import_zod15.z.string().min(1, "TimelineTrack.id is required"),
+  kind: import_zod15.z.enum(["video", "audio"]),
+  clips: import_zod15.z.array(TimelineClipSchema)
+});
+var TimelineSchema = import_zod15.z.object({
+  fps: import_zod15.z.number().int().positive("Timeline.fps must be a positive integer"),
+  totalFrames: import_zod15.z.number().int().min(0, "Timeline.totalFrames must be a non-negative integer"),
+  tracks: import_zod15.z.array(TimelineTrackSchema)
+});
+var SlideTransitionSchema = import_zod16.z.object({
+  kind: import_zod16.z.enum(["cut", "crossfade", "fade"]),
+  durationFrames: import_zod16.z.number().int().min(0, "transition durationFrames must be a non-negative integer").optional(),
+  color: import_zod16.z.string().optional()
+});
+var SlideRefSchema = import_zod16.z.object({
+  src: import_zod16.z.string().min(1, "SlideRef.src is required"),
+  duration: import_zod16.z.number().int().min(0, "SlideRef.duration must be a non-negative integer (frames)").optional(),
+  transition: SlideTransitionSchema.optional(),
+  label: import_zod16.z.string().optional()
+});
+var DesignRelationSchema = import_zod17.z.enum(["derived-from", "sibling", "references"]);
+var AtelierDesignRelationSchema = import_zod17.z.object({
+  source: import_zod17.z.string().min(1, "AtelierDesignRelation.source is required"),
+  relation: DesignRelationSchema,
+  note: import_zod17.z.string().optional()
+});
+var DesignTypographySchema = import_zod17.z.object({
+  headingFamily: import_zod17.z.string().optional(),
+  bodyFamily: import_zod17.z.string().optional(),
+  monoFamily: import_zod17.z.string().optional(),
+  sizes: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.number().positive()).optional(),
+  weights: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string()).optional()
+});
+var DesignMotionSchema = import_zod17.z.object({
+  defaultEasing: import_zod17.z.string().optional(),
+  defaultDuration: import_zod17.z.number().int().positive().optional()
+});
+var AtelierDesignSchema = import_zod17.z.object({
+  palette: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string()).optional(),
+  typography: DesignTypographySchema.optional(),
+  motion: DesignMotionSchema.optional(),
+  relatedTo: import_zod17.z.array(AtelierDesignRelationSchema).optional()
+});
 var CanvasSchema = import_zod14.z.object({
   width: import_zod14.z.number().int().positive("Canvas width must be a positive integer"),
   height: import_zod14.z.number().int().positive("Canvas height must be a positive integer"),
   fps: import_zod14.z.number().int().positive("FPS must be a positive integer"),
   background: import_zod14.z.string().optional()
 });
+var ProjectKindSchema = import_zod14.z.enum(["video", "image", "carousel"]);
 var AtelierDocumentSchema = import_zod14.z.object({
   version: import_zod14.z.string().min(1, "Version is required"),
   name: import_zod14.z.string().min(1, "Animation name is required"),
+  kind: ProjectKindSchema.optional(),
   description: import_zod14.z.string().optional(),
   tags: import_zod14.z.array(import_zod14.z.string()).optional(),
   canvas: CanvasSchema,
+  /** Per-file design / brand block (self-contained — no auto-merge). */
+  design: AtelierDesignSchema.optional(),
   variables: import_zod14.z.record(import_zod14.z.string(), VariableSchema).optional(),
   assets: import_zod14.z.record(import_zod14.z.string(), AssetSchema).optional(),
   presets: import_zod14.z.record(import_zod14.z.string(), PresetSchema).optional(),
   layers: import_zod14.z.array(LayerSchema),
-  states: import_zod14.z.record(import_zod14.z.string(), StateSchema)
+  states: import_zod14.z.record(import_zod14.z.string(), StateSchema),
+  /** Derived timeline summary for video-kind projects. Optional. */
+  timeline: TimelineSchema.optional(),
+  /** Carousel slides — only meaningful when kind === "carousel". */
+  slides: import_zod14.z.array(SlideRefSchema).optional()
 });
-var SilencePolicySchema = import_zod15.z.object({
-  noise: import_zod15.z.string().optional(),
-  min_silence: import_zod15.z.number().nonnegative().optional(),
-  default_padding_pre: import_zod15.z.number().nonnegative().optional(),
-  default_padding_post: import_zod15.z.number().nonnegative().optional(),
-  match_tolerance: import_zod15.z.number().nonnegative().optional()
+var SilencePolicySchema = import_zod18.z.object({
+  noise: import_zod18.z.string().optional(),
+  min_silence: import_zod18.z.number().nonnegative().optional(),
+  default_padding_pre: import_zod18.z.number().nonnegative().optional(),
+  default_padding_post: import_zod18.z.number().nonnegative().optional(),
+  match_tolerance: import_zod18.z.number().nonnegative().optional()
 }).strict();
-var CaptionStyleSchema = import_zod15.z.object({
-  font_family: import_zod15.z.string().optional(),
-  font_size: import_zod15.z.number().positive().optional(),
-  font_weight: import_zod15.z.union([import_zod15.z.literal("normal"), import_zod15.z.literal("bold"), import_zod15.z.number()]).optional(),
-  text_align: import_zod15.z.enum(["left", "center", "right"]).optional(),
-  color: import_zod15.z.string().optional(),
-  y_ratio: import_zod15.z.number().min(0).max(1).optional(),
-  width_ratio: import_zod15.z.number().min(0).max(1).optional(),
-  fade_seconds: import_zod15.z.number().nonnegative().optional()
+var CaptionStyleSchema = import_zod18.z.object({
+  font_family: import_zod18.z.string().optional(),
+  font_size: import_zod18.z.number().positive().optional(),
+  font_weight: import_zod18.z.union([import_zod18.z.literal("normal"), import_zod18.z.literal("bold"), import_zod18.z.number()]).optional(),
+  text_align: import_zod18.z.enum(["left", "center", "right"]).optional(),
+  color: import_zod18.z.string().optional(),
+  y_ratio: import_zod18.z.number().min(0).max(1).optional(),
+  width_ratio: import_zod18.z.number().min(0).max(1).optional(),
+  fade_seconds: import_zod18.z.number().nonnegative().optional()
 }).strict();
-var CaptionGroupingSchema = import_zod15.z.object({
-  max_words: import_zod15.z.number().int().positive().optional(),
-  pause_gap: import_zod15.z.number().nonnegative().optional()
+var CaptionGroupingSchema = import_zod18.z.object({
+  max_words: import_zod18.z.number().int().positive().optional(),
+  pause_gap: import_zod18.z.number().nonnegative().optional()
 }).strict();
-var OverlayAnchorSchema = import_zod15.z.enum([
+var OverlayAnchorSchema = import_zod18.z.enum([
   "top-left",
   "top-right",
   "bottom-left",
   "bottom-right"
 ]);
-var OverlayTextStyleSchema = import_zod15.z.object({
-  font_family: import_zod15.z.string().optional(),
-  font_size: import_zod15.z.number().positive().optional(),
-  font_weight: import_zod15.z.union([import_zod15.z.literal("normal"), import_zod15.z.literal("bold"), import_zod15.z.number()]).optional(),
-  color: import_zod15.z.string().optional()
+var OverlayTextStyleSchema = import_zod18.z.object({
+  font_family: import_zod18.z.string().optional(),
+  font_size: import_zod18.z.number().positive().optional(),
+  font_weight: import_zod18.z.union([import_zod18.z.literal("normal"), import_zod18.z.literal("bold"), import_zod18.z.number()]).optional(),
+  color: import_zod18.z.string().optional()
 }).strict();
 function validatePageNumberFormat(format, ctx) {
   if (format.length === 0) {
     ctx.addIssue({
-      code: import_zod15.z.ZodIssueCode.custom,
+      code: import_zod18.z.ZodIssueCode.custom,
       message: "format must be a non-empty string"
     });
     return;
@@ -1984,7 +2142,7 @@ function validatePageNumberFormat(format, ctx) {
   const close = (format.match(/\}/g) ?? []).length;
   if (open !== close) {
     ctx.addIssue({
-      code: import_zod15.z.ZodIssueCode.custom,
+      code: import_zod18.z.ZodIssueCode.custom,
       message: `format has unbalanced braces (${open} '{' vs ${close} '}')`
     });
     return;
@@ -1998,7 +2156,7 @@ function validatePageNumberFormat(format, ctx) {
     const inner = m[1];
     if (!groupRule.test(inner)) {
       ctx.addIssue({
-        code: import_zod15.z.ZodIssueCode.custom,
+        code: import_zod18.z.ZodIssueCode.custom,
         message: `format placeholder "{${inner}}" is not recognized \u2014 expected {current}, {total}, {current:0Nd}, or {total:0Nd}`
       });
       return;
@@ -2008,44 +2166,44 @@ function validatePageNumberFormat(format, ctx) {
   }
   if (!sawCurrent && !sawTotal) {
     ctx.addIssue({
-      code: import_zod15.z.ZodIssueCode.custom,
+      code: import_zod18.z.ZodIssueCode.custom,
       message: "format must contain at least one {current} or {total} placeholder"
     });
   }
 }
-var OverlayHandleRuleSchema = import_zod15.z.object({
-  text: import_zod15.z.string().min(1),
+var OverlayHandleRuleSchema = import_zod18.z.object({
+  text: import_zod18.z.string().min(1),
   anchor: OverlayAnchorSchema,
-  margin: import_zod15.z.number().nonnegative().optional(),
+  margin: import_zod18.z.number().nonnegative().optional(),
   style: OverlayTextStyleSchema.optional()
 }).strict();
-var OverlayPageNumberRuleSchema = import_zod15.z.object({
-  format: import_zod15.z.string().superRefine(validatePageNumberFormat),
+var OverlayPageNumberRuleSchema = import_zod18.z.object({
+  format: import_zod18.z.string().superRefine(validatePageNumberFormat),
   anchor: OverlayAnchorSchema,
-  margin: import_zod15.z.number().nonnegative().optional(),
+  margin: import_zod18.z.number().nonnegative().optional(),
   style: OverlayTextStyleSchema.optional()
 }).strict();
-var OverlayRulesSchema = import_zod15.z.object({
+var OverlayRulesSchema = import_zod18.z.object({
   handle: OverlayHandleRuleSchema.optional(),
   page_number: OverlayPageNumberRuleSchema.optional()
 }).strict();
-var StudioRecipeSchema = import_zod15.z.object({
-  version: import_zod15.z.string(),
-  name: import_zod15.z.string(),
-  description: import_zod15.z.string().optional(),
-  author: import_zod15.z.string().optional(),
-  tags: import_zod15.z.array(import_zod15.z.string()).optional(),
+var StudioRecipeSchema = import_zod18.z.object({
+  version: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  description: import_zod18.z.string().optional(),
+  author: import_zod18.z.string().optional(),
+  tags: import_zod18.z.array(import_zod18.z.string()).optional(),
   silence_policy: SilencePolicySchema.optional(),
   caption_style: CaptionStyleSchema.optional(),
   caption_grouping: CaptionGroupingSchema.optional(),
   // Phase 1.5 — first-class overlay rules
   overlay_rules: OverlayRulesSchema.optional(),
   // Reserved — Phase 3 (parse-opaque)
-  caption_highlight: import_zod15.z.unknown().optional(),
-  transition_kit: import_zod15.z.unknown().optional(),
-  palette: import_zod15.z.unknown().optional(),
-  audio_policy: import_zod15.z.unknown().optional(),
-  aspect_targets: import_zod15.z.array(import_zod15.z.unknown()).optional()
+  caption_highlight: import_zod18.z.unknown().optional(),
+  transition_kit: import_zod18.z.unknown().optional(),
+  palette: import_zod18.z.unknown().optional(),
+  audio_policy: import_zod18.z.unknown().optional(),
+  aspect_targets: import_zod18.z.array(import_zod18.z.unknown()).optional()
 }).strict();
 var RESERVED_RECIPE_FIELDS = [
   "caption_highlight",
@@ -2095,6 +2253,570 @@ function parseAtelier(yamlString) {
   }
   return validateDocument(parsed);
 }
+var SlotKindSchema = import_zod19.z.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 = import_zod19.z.string().superRefine((value, ctx) => {
+  const parsed = parseSlotRef(value);
+  if (parsed !== null) return;
+  const segments = value.split(".");
+  if (segments.length < 2) {
+    ctx.addIssue({
+      code: import_zod19.z.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: import_zod19.z.ZodIssueCode.custom,
+      message: `slot reference "${value}" has an empty segment`
+    });
+    return;
+  }
+  const kindOk = SlotKindSchema.safeParse(segments[0]).success;
+  if (!kindOk) {
+    ctx.addIssue({
+      code: import_zod19.z.ZodIssueCode.custom,
+      message: `slot reference "${value}" has unknown kind "${segments[0]}" \u2014 expected one of ${SLOT_KINDS.join(", ")}`
+    });
+    return;
+  }
+  ctx.addIssue({
+    code: import_zod19.z.ZodIssueCode.custom,
+    message: `slot reference "${value}" is malformed`
+  });
+});
+var TechniqueLibrarySchema = import_zod20.z.object({
+  version: import_zod20.z.number().int().positive(),
+  techniques: import_zod20.z.array(import_zod20.z.string().min(1))
+}).strict();
+var TECHNIQUE_LIBRARY_V1 = {
+  version: 1,
+  techniques: [
+    "text.split-reveal",
+    "image.ken-burns.slow",
+    "super.weight-pulse-on-keyword",
+    "background.color-shift-to-token"
+  ]
+};
+var TECHNIQUE_LIBRARY_V2 = {
+  version: 2,
+  techniques: [
+    // v1 (preserved)
+    "text.split-reveal",
+    "image.ken-burns.slow",
+    "super.weight-pulse-on-keyword",
+    "background.color-shift-to-token",
+    // v2 additions — text
+    "text.kinetic-keyword-emphasis",
+    "text.typewriter",
+    // v2 additions — image
+    "image.zoom-in-during-beat",
+    "image.cross-dissolve",
+    "image.parallax-pan-slow",
+    // v2 additions — transition
+    "transition.whip-pan",
+    "transition.match-cut",
+    "transition.morph-cut",
+    "transition.fade-through-color",
+    // v2 additions — super (overlay text)
+    "super.scale-in-spring",
+    "super.drop-in-staggered",
+    // v2 additions — audio
+    "audio.fade-under-vo"
+  ]
+};
+var TECHNIQUE_LIBRARIES = {
+  1: TECHNIQUE_LIBRARY_V1,
+  2: TECHNIQUE_LIBRARY_V2
+};
+function getTechniqueLibrary(version) {
+  return TECHNIQUE_LIBRARIES[version] ?? null;
+}
+var DesignAudienceSchema = import_zod21.z.object({
+  primary: import_zod21.z.string().min(1),
+  secondary: import_zod21.z.string().optional(),
+  platform: import_zod21.z.array(import_zod21.z.string().min(1)).min(1)
+}).strict();
+var DesignVoiceSchema = import_zod21.z.object({
+  descriptors: import_zod21.z.array(import_zod21.z.string().min(1)).min(3).max(5),
+  references: import_zod21.z.array(import_zod21.z.string().min(1)).optional()
+}).strict();
+var PaletteRoleSchema = import_zod21.z.enum([
+  "background",
+  "surface",
+  "primary",
+  "accent",
+  "text-on-dark",
+  "text-on-light"
+]);
+var PaletteEntrySchema = import_zod21.z.object({
+  token: import_zod21.z.string().min(1),
+  hex: import_zod21.z.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 = import_zod21.z.enum(["display", "body", "caption", "mono"]);
+var TypographyEntrySchema = import_zod21.z.object({
+  token: import_zod21.z.string().min(1),
+  family: import_zod21.z.string().min(1),
+  weights: import_zod21.z.array(import_zod21.z.number().int().min(1).max(1e3)).min(1),
+  usage: TypographyUsageSchema
+}).strict();
+var MotionRegisterSchema = import_zod21.z.object({
+  tempo: import_zod21.z.enum(["snappy", "steady", "calm", "languid"]),
+  easing_bias: import_zod21.z.enum(["linear", "ease-out", "spring"]),
+  camera_bias: import_zod21.z.enum(["static", "drift", "snap"]).optional()
+}).strict();
+var VisualRegisterSchema = import_zod21.z.object({
+  palette: import_zod21.z.array(PaletteEntrySchema).min(1),
+  typography: import_zod21.z.array(TypographyEntrySchema).min(1),
+  motion_register: MotionRegisterSchema
+}).strict();
+var AspectRatioSchema = import_zod21.z.enum(["9:16", "1:1", "16:9", "4:5"]);
+var DesignConstraintsSchema = import_zod21.z.object({
+  max_duration_seconds: import_zod21.z.number().positive().optional(),
+  aspect_ratios: import_zod21.z.array(AspectRatioSchema).min(1),
+  do_not: import_zod21.z.array(import_zod21.z.string().min(1))
+}).strict();
+var BrandLogoSchema = import_zod21.z.object({
+  token: import_zod21.z.string().min(1),
+  role: import_zod21.z.enum(["primary", "mark", "wordmark"])
+}).strict();
+var BrandHandleSchema = import_zod21.z.object({
+  platform: import_zod21.z.string().min(1),
+  value: import_zod21.z.string().min(1)
+}).strict();
+var BrandReferencesSchema = import_zod21.z.object({
+  logos: import_zod21.z.array(BrandLogoSchema).min(1),
+  handles: import_zod21.z.array(BrandHandleSchema).optional(),
+  page_number_convention: import_zod21.z.string().optional()
+}).strict();
+var DesignVarianceSchema = import_zod21.z.object({
+  field: import_zod21.z.string().min(1),
+  value: import_zod21.z.unknown(),
+  reason: import_zod21.z.string().min(1)
+}).strict();
+var DesignArtifactSchema = import_zod21.z.object({
+  audience: DesignAudienceSchema,
+  voice: DesignVoiceSchema,
+  visual_register: VisualRegisterSchema,
+  constraints: DesignConstraintsSchema,
+  brand_references: BrandReferencesSchema,
+  variances: import_zod21.z.array(DesignVarianceSchema).optional(),
+  /** Markdown body verbatim — attached by the parser, not part of frontmatter. */
+  body: import_zod21.z.string()
+}).strict();
+var BEAT_ID_RE = /^[a-z][a-z0-9-]*(\.[a-z0-9][a-z0-9-]*)*$/;
+var ScriptBeatIdSchema = import_zod22.z.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 = import_zod22.z.object({
+  id: ScriptBeatIdSchema,
+  copy: import_zod22.z.string().min(1),
+  intent: import_zod22.z.string().min(1),
+  est_duration_s: import_zod22.z.number().nonnegative(),
+  bind_to_transcript: import_zod22.z.boolean().default(true)
+}).strict();
+var NonNarratedBeatSchema = import_zod22.z.object({
+  id: ScriptBeatIdSchema,
+  copy: import_zod22.z.string().min(1),
+  intent: import_zod22.z.string().min(1),
+  est_duration_s: import_zod22.z.number().nonnegative()
+}).strict();
+var NarratedBlocksSchema = import_zod22.z.object({
+  hook: import_zod22.z.array(NarratedBeatSchema).min(1),
+  story: import_zod22.z.array(NarratedBeatSchema),
+  proof: import_zod22.z.array(NarratedBeatSchema),
+  cta: import_zod22.z.array(NarratedBeatSchema).min(1)
+}).strict();
+var NarratedScriptSchema = import_zod22.z.object({
+  mode: import_zod22.z.literal("narrated"),
+  target_duration_s: import_zod22.z.number().positive(),
+  language: import_zod22.z.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: import_zod22.z.string()
+}).strict();
+var CarouselScriptSchema = import_zod22.z.object({
+  mode: import_zod22.z.literal("carousel"),
+  target_duration_s: import_zod22.z.number().positive(),
+  language: import_zod22.z.string().min(1),
+  tts_voice: SlotRefSchema.optional(),
+  beats: import_zod22.z.array(NonNarratedBeatSchema).min(1),
+  body: import_zod22.z.string()
+}).strict();
+var TextOnlyScriptSchema = import_zod22.z.object({
+  mode: import_zod22.z.literal("text-only"),
+  target_duration_s: import_zod22.z.number().positive(),
+  language: import_zod22.z.string().min(1),
+  tts_voice: SlotRefSchema.optional(),
+  beats: import_zod22.z.array(NonNarratedBeatSchema).min(1),
+  body: import_zod22.z.string()
+}).strict();
+var ScriptArtifactSchema = import_zod22.z.discriminatedUnion("mode", [
+  NarratedScriptSchema,
+  CarouselScriptSchema,
+  TextOnlyScriptSchema
+]);
+function allScriptBeats(script) {
+  if (script.mode === "narrated") {
+    return [
+      ...script.blocks.hook,
+      ...script.blocks.story,
+      ...script.blocks.proof,
+      ...script.blocks.cta
+    ];
+  }
+  return script.beats;
+}
+var BeatWindowSchema = import_zod23.z.object({
+  start_s: import_zod23.z.number().nonnegative(),
+  end_s: import_zod23.z.number().nonnegative()
+}).strict().refine((w) => w.end_s > w.start_s, {
+  message: "window.end_s must be > window.start_s"
+});
+var CameraSchema = import_zod23.z.object({
+  kind: import_zod23.z.enum(["static", "drift", "push", "pull", "whip"]),
+  subject: import_zod23.z.string().min(1).optional()
+}).strict();
+var MoodSchema = import_zod23.z.string().min(1);
+var TransitionKindSchema = import_zod23.z.enum(["cut", "dip-to-color", "whip", "crossfade"]);
+var TransitionOutSchema = import_zod23.z.object({
+  kind: TransitionKindSchema,
+  duration_s: import_zod23.z.number().nonnegative().optional(),
+  color: import_zod23.z.string().min(1).optional()
+}).strict();
+var SfxEntrySchema = import_zod23.z.object({
+  slot: SlotRefSchema,
+  gain_db: import_zod23.z.number()
+}).strict();
+var StoryboardBeatSchema = import_zod23.z.object({
+  id: ScriptBeatIdSchema,
+  window: BeatWindowSchema,
+  mood: import_zod23.z.array(MoodSchema).min(1),
+  camera: CameraSchema,
+  slots: import_zod23.z.array(SlotRefSchema),
+  techniques: import_zod23.z.array(import_zod23.z.string().min(1)),
+  transition_out: TransitionOutSchema,
+  sfx: import_zod23.z.array(SfxEntrySchema).optional()
+}).strict();
+var StoryboardAspectRatioSchema = import_zod23.z.enum(["9:16", "1:1", "16:9", "4:5"]);
+var StoryboardArtifactSchema = import_zod23.z.object({
+  technique_library_version: import_zod23.z.number().int().positive(),
+  aspect_ratio: StoryboardAspectRatioSchema,
+  beats: import_zod23.z.array(StoryboardBeatSchema).min(1)
+}).strict();
+function isBRollBeatId(id) {
+  return id.startsWith("b-roll.");
+}
+var FRONTMATTER_FENCE = "---";
+function splitFrontmatter(raw) {
+  const text = raw.replace(/\r\n/g, "\n").replace(/^/, "");
+  const lines = text.split("\n");
+  let i = 0;
+  while (i < lines.length && lines[i].trim() === "") i++;
+  if (i >= lines.length || lines[i].trim() !== FRONTMATTER_FENCE) {
+    throw new Error("artifact missing leading `---` frontmatter fence");
+  }
+  const startLine = i + 1;
+  let endLine = -1;
+  for (let j = startLine; j < lines.length; j++) {
+    if (lines[j].trim() === FRONTMATTER_FENCE) {
+      endLine = j;
+      break;
+    }
+  }
+  if (endLine === -1) {
+    throw new Error("artifact missing closing `---` frontmatter fence");
+  }
+  const frontmatterText = lines.slice(startLine, endLine).join("\n");
+  const body = lines.slice(endLine + 1).join("\n").replace(/^\n+/, "");
+  let frontmatter;
+  try {
+    frontmatter = frontmatterText.trim().length === 0 ? {} : (0, import_yaml2.parse)(frontmatterText);
+  } catch (err) {
+    throw new Error(`frontmatter YAML parse error: ${err.message}`);
+  }
+  if (frontmatter === null || typeof frontmatter !== "object" || Array.isArray(frontmatter)) {
+    throw new Error("frontmatter must be a YAML mapping");
+  }
+  return { frontmatter, body };
+}
+function parseDesign(raw) {
+  const { frontmatter, body } = splitFrontmatter(raw);
+  return DesignArtifactSchema.parse({ ...frontmatter, body });
+}
+var NARRATED_SECTION_HEADERS = {
+  hook: "hook",
+  story: "story",
+  proof: "proof",
+  cta: "cta"
+};
+function parseScriptBody(body, mode) {
+  const text = body.replace(/\r\n/g, "\n");
+  const lines = text.split("\n");
+  if (mode === "narrated") {
+    const blocks = {
+      hook: [],
+      story: [],
+      proof: [],
+      cta: []
+    };
+    let currentKey = null;
+    let buffer = [];
+    const remainder2 = [];
+    const flush = () => {
+      if (currentKey === null) return;
+      const yamlText2 = buffer.join("\n").trim();
+      if (yamlText2.length === 0) return;
+      const parsed = (0, import_yaml2.parse)(yamlText2);
+      if (!Array.isArray(parsed)) {
+        throw new Error(`SCRIPT section "${currentKey}" must be a YAML list of beats`);
+      }
+      blocks[currentKey] = parsed;
+    };
+    for (const line of lines) {
+      const headingMatch = /^#\s+(.+?)\s*$/.exec(line);
+      if (headingMatch) {
+        const key = headingMatch[1].toLowerCase();
+        if (key in NARRATED_SECTION_HEADERS) {
+          flush();
+          currentKey = NARRATED_SECTION_HEADERS[key];
+          buffer = [];
+          continue;
+        }
+      }
+      if (currentKey === null) {
+        remainder2.push(line);
+      } else {
+        buffer.push(line);
+      }
+    }
+    flush();
+    return { blocks, remainder: remainder2.join("\n").trim() };
+  }
+  const beatLines = [];
+  const remainder = [];
+  let inBeats = false;
+  let sawAnyHeading = false;
+  for (const line of lines) {
+    const headingMatch = /^#\s+(.+?)\s*$/.exec(line);
+    if (headingMatch) {
+      sawAnyHeading = true;
+      inBeats = headingMatch[1].toLowerCase() === "beats";
+      continue;
+    }
+    if (sawAnyHeading) {
+      if (inBeats) beatLines.push(line);
+      else remainder.push(line);
+    } else {
+      beatLines.push(line);
+    }
+  }
+  const yamlText = beatLines.join("\n").trim();
+  let beats = [];
+  if (yamlText.length > 0) {
+    const parsed = (0, import_yaml2.parse)(yamlText);
+    if (!Array.isArray(parsed)) {
+      throw new Error(`SCRIPT body must be a YAML list of beats (mode: ${mode})`);
+    }
+    beats = parsed;
+  }
+  return { beats, remainder: remainder.join("\n").trim() };
+}
+function parseScript(raw) {
+  const { frontmatter, body } = splitFrontmatter(raw);
+  const mode = frontmatter.mode;
+  if (mode !== "narrated" && mode !== "carousel" && mode !== "text-only") {
+    throw new Error(`SCRIPT frontmatter "mode" must be one of narrated | carousel | text-only (got ${JSON.stringify(mode)})`);
+  }
+  const parsed = parseScriptBody(body, mode);
+  const assembled = { ...frontmatter, body: parsed.remainder };
+  if (mode === "narrated") {
+    assembled.blocks = parsed.blocks;
+  } else {
+    assembled.beats = parsed.beats;
+  }
+  return ScriptArtifactSchema.parse(assembled);
+}
+function parseStoryboardBody(body) {
+  const text = body.replace(/\r\n/g, "\n");
+  const lines = text.split("\n");
+  const beats = [];
+  let current = null;
+  for (const line of lines) {
+    const headingMatch = /^##\s+(.+?)\s*$/.exec(line);
+    if (headingMatch) {
+      if (current !== null) beats.push(current);
+      current = { id: headingMatch[1].trim(), buffer: [] };
+      continue;
+    }
+    if (current !== null) {
+      current.buffer.push(line);
+    }
+  }
+  if (current !== null) beats.push(current);
+  return beats.map(({ id, buffer }) => {
+    const yamlText = buffer.join("\n").trim();
+    if (yamlText.length === 0) {
+      return { id };
+    }
+    const parsed = (0, import_yaml2.parse)(yamlText);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`STORYBOARD beat "${id}" body must be a YAML mapping`);
+    }
+    return { id, ...parsed };
+  });
+}
+function parseStoryboard(raw) {
+  const { frontmatter, body } = splitFrontmatter(raw);
+  const beats = parseStoryboardBody(body);
+  return StoryboardArtifactSchema.parse({ ...frontmatter, beats });
+}
+function validateArtifactSet(set) {
+  const warnings = [];
+  const errors = [];
+  if (set.storyboard && set.script) {
+    const scriptIds = new Set(allScriptBeats(set.script).map((b) => b.id));
+    for (const beat of set.storyboard.beats) {
+      if (isBRollBeatId(beat.id)) continue;
+      if (!scriptIds.has(beat.id)) {
+        errors.push(
+          `STORYBOARD beat "${beat.id}" has no matching SCRIPT beat (and is not prefixed b-roll.)`
+        );
+      }
+    }
+  }
+  if (set.storyboard) {
+    for (const beat of set.storyboard.beats) {
+      for (const slot of beat.slots) {
+        const parsed = parseSlotRef(slot);
+        if (parsed === null) {
+          errors.push(
+            `STORYBOARD beat "${beat.id}" slot "${slot}" is malformed or has an unknown kind (expected one of ${SLOT_KINDS.join(", ")})`
+          );
+        }
+      }
+      if (beat.sfx) {
+        for (const sfx of beat.sfx) {
+          const parsed = parseSlotRef(sfx.slot);
+          if (parsed === null) {
+            errors.push(
+              `STORYBOARD beat "${beat.id}" sfx slot "${sfx.slot}" is malformed or has an unknown kind`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (set.storyboard) {
+    const lib = getTechniqueLibrary(set.storyboard.technique_library_version);
+    if (lib === null) {
+      errors.push(
+        `STORYBOARD references unknown technique_library_version ${set.storyboard.technique_library_version}`
+      );
+    } else {
+      const known = new Set(lib.techniques);
+      for (const beat of set.storyboard.beats) {
+        for (const t of beat.techniques) {
+          if (!known.has(t)) {
+            errors.push(
+              `STORYBOARD beat "${beat.id}" uses unknown technique "${t}" (technique_library_version=${lib.version})`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (set.script) {
+    const sum = allScriptBeats(set.script).reduce((acc, b) => acc + b.est_duration_s, 0);
+    if (sum > set.script.target_duration_s) {
+      warnings.push(
+        `SCRIPT beat est_duration_s sum (${sum.toFixed(2)}s) exceeds target_duration_s (${set.script.target_duration_s}s) \u2014 warn only pre-VO; will hard-fail post-transcript binding`
+      );
+    }
+  }
+  return { ok: errors.length === 0, warnings, errors };
+}
+var WorkspaceManifestSchema = import_zod24.z.object({
+  /** Manifest schema version. Pinned to '1.0' for the initial release. */
+  version: import_zod24.z.literal("1.0"),
+  /** Display name; defaults to the workspace dir basename at create time. */
+  name: import_zod24.z.string().min(1),
+  /** ISO 8601 timestamp set by the writer. */
+  created: import_zod24.z.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: import_zod24.z.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: import_zod24.z.array(import_zod24.z.string().min(1)).optional(),
+  /** Free-text creator description. Optional. */
+  description: import_zod24.z.string().optional()
+}).strict();
+var NonEmptyStringListSchema = import_zod25.z.array(import_zod25.z.string().min(1));
+var MediaNotesConstraintsSchema = import_zod25.z.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 = import_zod25.z.object({
+  /** Basename of the media file this notes file sits next to. */
+  file: import_zod25.z.string().min(1),
+  /** ISO 8601 timestamp captured at ingest. */
+  added: import_zod25.z.string().min(1),
+  /** User identifier (env $USER at ingest, "creator" fallback). */
+  added_by: import_zod25.z.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 = import_zod25.z.object({
+  frontmatter: MediaNotesFrontmatterSchema,
+  body: import_zod25.z.string()
+}).strict();
+var MediaNotesAuthorSchema = import_zod25.z.enum(["lux", "quill", "iris", "creator"]);
 
 // src/commands/validate.ts
 init_dist2();
@@ -2328,21 +3050,78 @@ function stillCommand(program) {
 }
 
 // src/commands/render.ts
-var import_node_fs4 = require("fs");
-var import_node_path4 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path5 = require("path");
 
 // src/commands/render-pipeline.ts
 var import_node_child_process = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
 init_dist2();
 init_dist3();
 async function checkFfmpeg() {
-  return new Promise((resolve14) => {
+  return new Promise((resolve28) => {
     const proc = (0, import_node_child_process.spawn)("ffmpeg", ["-version"], { stdio: "pipe" });
-    proc.on("error", () => resolve14(false));
-    proc.on("close", (code) => resolve14(code === 0));
+    proc.on("error", () => resolve28(false));
+    proc.on("close", (code) => resolve28(code === 0));
   });
 }
-function buildFfmpegArgs(width, height, fps, format, output) {
+function buildFfmpegArgs(width, height, fps, format, output, sourceVideoPath) {
+  if (sourceVideoPath && format === "mp4") {
+    return [
+      "-y",
+      // Input 0: source video (+ audio). ffmpeg auto-decodes via libavformat.
+      "-i",
+      sourceVideoPath,
+      // Input 1: canvas overlay frames on stdin. Same dimensions + fps as
+      // the doc so the overlay aligns frame-for-frame with input 0.
+      "-f",
+      "rawvideo",
+      "-pix_fmt",
+      "bgra",
+      "-s",
+      `${width}x${height}`,
+      "-r",
+      String(fps),
+      "-i",
+      "pipe:0",
+      // Filter graph:
+      //   1. Scale + pad the source video to the doc's canvas dimensions
+      //      with `force_original_aspect_ratio=decrease` (letterbox-fit, no
+      //      crop) so a 4K iPhone source rendered into a 1080x1920 doc
+      //      respects the doc's intent instead of upscaling everything to
+      //      source dimensions. The pad fills gutters with black if the
+      //      source aspect differs from the canvas aspect.
+      //   2. Overlay the caption canvas on top. Canvas frames must have
+      //      transparent backgrounds — renderFrame's clearRect (fixed
+      //      2026-05-28) gives true transparency by default.
+      "-filter_complex",
+      `[0:v]scale=${width}:${height}:force_original_aspect_ratio=decrease,pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2:color=black[bg];[bg][1:v]overlay=0:0[v]`,
+      "-map",
+      "[v]",
+      // Copy the source audio track verbatim. No re-encode.
+      "-map",
+      "0:a?",
+      "-c:v",
+      "libx264",
+      "-pix_fmt",
+      "yuv420p",
+      "-preset",
+      "medium",
+      "-crf",
+      "18",
+      "-c:a",
+      "copy",
+      // `-shortest` so the output ends with whichever stream finishes first
+      // (typically the source video — we render exactly that many canvas
+      // frames). Without it, if the canvas had a few extra frames the
+      // output would have a silent tail.
+      "-shortest",
+      "-movflags",
+      "+faststart",
+      output
+    ];
+  }
   const input = [
     "-y",
     "-f",
@@ -2381,6 +3160,21 @@ function buildFfmpegArgs(width, height, fps, format, output) {
     output
   ];
 }
+function findPrimaryVideoSource(doc, docPath) {
+  for (const layer of doc.layers) {
+    if (layer.visual.type !== "video") continue;
+    const v = layer.visual;
+    const src = v.src ?? (v.assetId ? doc.assets?.[v.assetId]?.src : void 0);
+    if (!src) continue;
+    if ((0, import_node_path4.isAbsolute)(src)) {
+      return (0, import_node_fs4.existsSync)(src) ? src : null;
+    }
+    if (!docPath) return null;
+    const absolute = (0, import_node_path4.resolve)((0, import_node_path4.dirname)(docPath), src);
+    return (0, import_node_fs4.existsSync)(absolute) ? absolute : null;
+  }
+  return null;
+}
 async function preloadImages(doc, loadImage2) {
   const sources = /* @__PURE__ */ new Set();
   for (const layer of doc.layers) {
@@ -2419,7 +3213,7 @@ async function preloadImages(doc, loadImage2) {
   for (const src of preloaded.keys()) {
     imageCache.load(src);
   }
-  await new Promise((resolve14) => process.nextTick(resolve14));
+  await new Promise((resolve28) => process.nextTick(resolve28));
   return imageCache;
 }
 async function renderDocument(doc, opts) {
@@ -2464,7 +3258,8 @@ async function renderDocument(doc, opts) {
   const imageCache = await preloadImages(doc, loadImage2);
   const canvas = createCanvas2(width, height);
   const ctx = canvas.getContext("2d");
-  const ffmpegArgs = buildFfmpegArgs(width, height, fps, format, output);
+  const sourceVideoPath = findPrimaryVideoSource(doc, opts.docPath) ?? void 0;
+  const ffmpegArgs = buildFfmpegArgs(width, height, fps, format, output, sourceVideoPath);
   const ffmpeg = (0, import_node_child_process.spawn)("ffmpeg", ffmpegArgs, {
     stdio: ["pipe", "pipe", "pipe"]
   });
@@ -2483,7 +3278,7 @@ async function renderDocument(doc, opts) {
       const canWrite = ffmpeg.stdin.write(raw);
       if (!canWrite) {
         await new Promise(
-          (resolve14) => ffmpeg.stdin.once("drain", resolve14)
+          (resolve28) => ffmpeg.stdin.once("drain", resolve28)
         );
       }
       frameIndex++;
@@ -2496,8 +3291,8 @@ async function renderDocument(doc, opts) {
     }
   }
   ffmpeg.stdin.end();
-  const exitCode = await new Promise((resolve14) => {
-    ffmpeg.on("close", resolve14);
+  const exitCode = await new Promise((resolve28) => {
+    ffmpeg.on("close", resolve28);
   });
   if (exitCode !== 0) {
     throw new Error(
@@ -2516,10 +3311,10 @@ ${stderrOutput.slice(-500)}`
 
 // src/commands/render.ts
 function readAndParse3(file) {
-  const absPath = (0, import_node_path4.resolve)(file);
+  const absPath = (0, import_node_path5.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs4.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs5.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -2536,7 +3331,7 @@ function readAndParse3(file) {
 }
 function inferFormat(output) {
   if (!output) return "mp4";
-  const ext = (0, import_node_path4.extname)(output).toLowerCase();
+  const ext = (0, import_node_path5.extname)(output).toLowerCase();
   if (ext === ".gif") return "gif";
   return "mp4";
 }
@@ -2570,14 +3365,20 @@ function renderCommand(program) {
       } else {
         format = inferFormat(options.output);
       }
-      const inputName = (0, import_node_path4.basename)(file, (0, import_node_path4.extname)(file));
+      const inputName = (0, import_node_path5.basename)(file, (0, import_node_path5.extname)(file));
       const output = options.output ?? `${inputName}.${format}`;
       const startTime = Date.now();
       try {
         const result = await renderDocument(doc, {
-          output: (0, import_node_path4.resolve)(output),
+          output: (0, import_node_path5.resolve)(output),
           format,
           states: options.state,
+          // Absolute path of the input doc — the pipeline uses this to
+          // resolve relative `media/...` paths in VideoVisual layers so
+          // ffmpeg can read the source video as a second input (overlay
+          // base + audio passthrough). Without this, render falls back to
+          // canvas-only mode — no source pixels, no audio.
+          docPath: (0, import_node_path5.resolve)(file),
           onProgress: ({ frame, totalFrames, state, percent }) => {
             const elapsed = (Date.now() - startTime) / 1e3;
             const rate = elapsed > 0 ? frame / elapsed : 0;
@@ -2601,8 +3402,8 @@ function renderCommand(program) {
 }
 
 // src/commands/export-svg.ts
-var import_node_fs5 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path6 = require("path");
 
 // ../svg/dist/index.js
 init_dist2();
@@ -3067,10 +3868,10 @@ function renderRefSVG(eff, visual, _parentDoc, opts, _depth, _visitedRefs) {
 
 // src/commands/export-svg.ts
 function readAndParse4(file) {
-  const absPath = (0, import_node_path5.resolve)(file);
+  const absPath = (0, import_node_path6.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs5.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs6.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -3112,7 +3913,7 @@ function exportSvgCommand(program) {
           xmlDeclaration: options.xmlDeclaration
         });
         if (options.output) {
-          (0, import_node_fs5.writeFileSync)((0, import_node_path5.resolve)(options.output), svg, "utf-8");
+          (0, import_node_fs6.writeFileSync)((0, import_node_path6.resolve)(options.output), svg, "utf-8");
         } else {
           console.log(svg);
         }
@@ -3125,8 +3926,8 @@ function exportSvgCommand(program) {
 }
 
 // src/commands/export-lottie.ts
-var import_node_fs6 = require("fs");
-var import_node_path6 = require("path");
+var import_node_fs7 = require("fs");
+var import_node_path7 = require("path");
 
 // ../lottie/dist/index.js
 function colorToLottie(color) {
@@ -3620,8 +4421,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)) {
@@ -3695,10 +4499,10 @@ function exportToLottie(doc, opts) {
 
 // src/commands/export-lottie.ts
 function readAndParse5(file) {
-  const absPath = (0, import_node_path6.resolve)(file);
+  const absPath = (0, import_node_path7.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs6.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs7.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -3726,7 +4530,7 @@ function exportLottieCommand(program) {
         }
         const output = JSON.stringify(json, null, 2);
         if (options.output) {
-          (0, import_node_fs6.writeFileSync)((0, import_node_path6.resolve)(options.output), output, "utf-8");
+          (0, import_node_fs7.writeFileSync)((0, import_node_path7.resolve)(options.output), output, "utf-8");
         } else {
           console.log(output);
         }
@@ -3739,8 +4543,8 @@ function exportLottieCommand(program) {
 }
 
 // src/commands/export-image.ts
-var import_node_fs7 = require("fs");
-var import_node_path7 = require("path");
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
 
 // src/lib/render-image.ts
 init_dist2();
@@ -3833,7 +4637,7 @@ async function preloadImages2(doc, loadImage2) {
     }
   });
   for (const src of preloaded.keys()) imageCache.load(src);
-  await new Promise((resolve14) => process.nextTick(resolve14));
+  await new Promise((resolve28) => process.nextTick(resolve28));
   return { imageCache, loaded: preloaded };
 }
 async function renderDocumentToPng(doc, opts = {}) {
@@ -3891,10 +4695,10 @@ async function renderDocumentToPng(doc, opts = {}) {
 
 // src/commands/export-image.ts
 function readAndParse6(file) {
-  const absPath = (0, import_node_path7.resolve)(file);
+  const absPath = (0, import_node_path8.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs7.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs8.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -3938,7 +4742,7 @@ function exportImageCommand(program) {
         width,
         height
       });
-      (0, import_node_fs7.writeFileSync)((0, import_node_path7.resolve)(options.out), buffer);
+      (0, import_node_fs8.writeFileSync)((0, import_node_path8.resolve)(options.out), buffer);
     } catch (err) {
       if (err instanceof CanvasUnavailableError) {
         console.error(err.message);
@@ -3952,29 +4756,29 @@ function exportImageCommand(program) {
 }
 
 // src/commands/carousel.ts
-var import_node_fs9 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path10 = require("path");
 
 // src/lib/recipe.ts
-var import_node_fs8 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path9 = require("path");
 var import_node_os = require("os");
-var import_yaml2 = require("yaml");
+var import_yaml3 = require("yaml");
 var RECIPE_VERSION = "1.0";
 function resolveRecipePath(pathOrName, projectDir) {
-  if ((0, import_node_path8.isAbsolute)(pathOrName) || pathOrName.includes("/") || pathOrName.includes("\\")) {
-    return (0, import_node_path8.resolve)(pathOrName);
+  if ((0, import_node_path9.isAbsolute)(pathOrName) || pathOrName.includes("/") || pathOrName.includes("\\")) {
+    return (0, import_node_path9.resolve)(pathOrName);
   }
   const candidates = [];
   const exts = [".recipe.yaml", ".recipe.json", ".yaml", ".yml", ".json"];
   if (projectDir) {
-    const projectRecipesDir = (0, import_node_path8.join)((0, import_node_path8.resolve)(projectDir), ".atelier", "recipes");
-    for (const ext of exts) candidates.push((0, import_node_path8.join)(projectRecipesDir, `${pathOrName}${ext}`));
+    const projectRecipesDir = (0, import_node_path9.join)((0, import_node_path9.resolve)(projectDir), ".atelier", "recipes");
+    for (const ext of exts) candidates.push((0, import_node_path9.join)(projectRecipesDir, `${pathOrName}${ext}`));
   }
-  const userRecipesDir = (0, import_node_path8.join)((0, import_node_os.homedir)(), ".atelier", "recipes");
-  for (const ext of exts) candidates.push((0, import_node_path8.join)(userRecipesDir, `${pathOrName}${ext}`));
+  const userRecipesDir = (0, import_node_path9.join)((0, import_node_os.homedir)(), ".atelier", "recipes");
+  for (const ext of exts) candidates.push((0, import_node_path9.join)(userRecipesDir, `${pathOrName}${ext}`));
   for (const candidate of candidates) {
-    if ((0, import_node_fs8.existsSync)(candidate)) return candidate;
+    if ((0, import_node_fs9.existsSync)(candidate)) return candidate;
   }
   throw new Error(
     `Recipe "${pathOrName}" not found. Looked in:
@@ -3983,12 +4787,12 @@ ${candidates.map((c) => `  ${c}`).join("\n")}`
 }
 function loadRecipe(pathOrName, projectDir) {
   const path = resolveRecipePath(pathOrName, projectDir);
-  const raw = (0, import_node_fs8.readFileSync)(path, "utf-8");
+  const raw = (0, import_node_fs9.readFileSync)(path, "utf-8");
   let parsed;
   if (path.endsWith(".json")) {
     parsed = JSON.parse(raw);
   } else {
-    parsed = (0, import_yaml2.parse)(raw);
+    parsed = (0, import_yaml3.parse)(raw);
   }
   const result = validateRecipe(parsed);
   if (!result.success) {
@@ -4145,7 +4949,7 @@ function renderRecipeWithDefaults(recipe) {
   };
 }
 function recipeToYaml(recipe) {
-  return (0, import_yaml2.stringify)(recipe);
+  return (0, import_yaml3.stringify)(recipe);
 }
 var DEFAULT_OVERLAY_MARGIN = 24;
 var DEFAULT_OVERLAY_TEXT_STYLE = {
@@ -4256,45 +5060,45 @@ function renderPageNumberFormat(format, currentIndex, totalCount) {
 var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp"]);
 var DEFAULT_CANVAS = 1080;
 function expandInputs(pattern) {
-  const abs = (0, import_node_path9.resolve)(pattern);
+  const abs = (0, import_node_path10.resolve)(pattern);
   let isDir = false;
   try {
-    isDir = (0, import_node_fs9.statSync)(abs).isDirectory();
+    isDir = (0, import_node_fs10.statSync)(abs).isDirectory();
   } catch {
     isDir = false;
   }
   if (isDir) {
     return listImages(abs);
   }
-  const dir = (0, import_node_path9.dirname)(abs);
-  const base = (0, import_node_path9.basename)(abs);
+  const dir = (0, import_node_path10.dirname)(abs);
+  const base = (0, import_node_path10.basename)(abs);
   if (base.includes("*")) {
     const matcher = globToRegExp(base);
     let entries;
     try {
-      entries = (0, import_node_fs9.readdirSync)(dir);
+      entries = (0, import_node_fs10.readdirSync)(dir);
     } catch {
       return [];
     }
-    return entries.filter((name) => matcher.test(name) && isImageFile(name)).map((name) => (0, import_node_path9.join)(dir, name)).sort();
+    return entries.filter((name) => matcher.test(name) && isImageFile(name)).map((name) => (0, import_node_path10.join)(dir, name)).sort();
   }
   return isImageFile(base) ? [abs] : [];
 }
 function listImages(dir) {
   let entries;
   try {
-    entries = (0, import_node_fs9.readdirSync)(dir);
+    entries = (0, import_node_fs10.readdirSync)(dir);
   } catch {
     return [];
   }
-  return entries.filter(isImageFile).map((name) => (0, import_node_path9.join)(dir, name)).sort();
+  return entries.filter(isImageFile).map((name) => (0, import_node_path10.join)(dir, name)).sort();
 }
 function isImageFile(name) {
-  return IMAGE_EXTS.has((0, import_node_path9.extname)(name).toLowerCase());
+  return IMAGE_EXTS.has((0, import_node_path10.extname)(name).toLowerCase());
 }
 function globToRegExp(glob) {
   const escaped = glob.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const pattern = escaped.replace(/\*/g, `[^${import_node_path9.sep === "\\" ? "\\\\" : import_node_path9.sep}]*`).replace(/\?/g, ".");
+  const pattern = escaped.replace(/\*/g, `[^${import_node_path10.sep === "\\" ? "\\\\" : import_node_path10.sep}]*`).replace(/\?/g, ".");
   return new RegExp(`^${pattern}$`);
 }
 function composeCarouselFrameDoc(args) {
@@ -4324,8 +5128,8 @@ function composeCarouselFrameDoc(args) {
 function carouselFileName(index, total, imagePath) {
   const padWidth = Math.max(2, String(total).length);
   const prefix = String(index).padStart(padWidth, "0");
-  const ext = (0, import_node_path9.extname)(imagePath);
-  const stem = (0, import_node_path9.basename)(imagePath, ext);
+  const ext = (0, import_node_path10.extname)(imagePath);
+  const stem = (0, import_node_path10.basename)(imagePath, ext);
   return `${prefix}-${stem}.png`;
 }
 function parseDim2(raw, name) {
@@ -4368,9 +5172,9 @@ function carouselCommand(program) {
       process.exit(1);
       return;
     }
-    const outDir = (0, import_node_path9.resolve)(options.outDir);
+    const outDir = (0, import_node_path10.resolve)(options.outDir);
     try {
-      (0, import_node_fs9.mkdirSync)(outDir, { recursive: true });
+      (0, import_node_fs10.mkdirSync)(outDir, { recursive: true });
     } catch (err) {
       console.error(`atelier carousel: cannot create out-dir ${outDir}: ${err.message}`);
       process.exit(1);
@@ -4396,8 +5200,8 @@ function carouselCommand(program) {
           refitImageBounds: ({ canvas, natural }) => fitImageToCanvas(canvas, natural)
         });
         const outName = carouselFileName(index, total, imagePath);
-        (0, import_node_fs9.writeFileSync)((0, import_node_path9.join)(outDir, outName), buffer);
-        console.log(`  [${index}/${total}] ${(0, import_node_path9.basename)(imagePath)} \u2192 ${outName}`);
+        (0, import_node_fs10.writeFileSync)((0, import_node_path10.join)(outDir, outName), buffer);
+        console.log(`  [${index}/${total}] ${(0, import_node_path10.basename)(imagePath)} \u2192 ${outName}`);
       }
     } catch (err) {
       if (err instanceof CanvasUnavailableError) {
@@ -4415,20 +5219,21 @@ Done. ${total} image${total === 1 ? "" : "s"} \u2192 ${outDir}`);
 }
 
 // src/commands/assets.ts
-var import_node_fs10 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path11 = require("path");
 function getAssets(doc) {
   const assets = doc.assets ?? {};
   return Object.entries(assets).map(([assetId, asset]) => {
-    const usedByLayers = doc.layers.filter((l) => l.visual.type === "image" && l.visual.assetId === assetId).map((l) => l.id);
-    const usedByStates = Object.entries(doc.states).filter(([, state]) => state.audio?.src === assetId).map(([name]) => name);
+    const usedByLayers = 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,
-      usedByStates
+      usedByLayers
     };
   });
 }
@@ -4441,17 +5246,14 @@ function formatAssets(assets) {
     if (a.usedByLayers.length > 0) {
       lines.push(`    Layers: ${a.usedByLayers.join(", ")}`);
     }
-    if (a.usedByStates.length > 0) {
-      lines.push(`    States: ${a.usedByStates.join(", ")}`);
-    }
   }
   return lines.join("\n");
 }
 function readAndParse7(file) {
-  const absPath = (0, import_node_path10.resolve)(file);
+  const absPath = (0, import_node_path11.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs10.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs11.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -4475,8 +5277,8 @@ function assetsCommand(program) {
 }
 
 // src/commands/variables.ts
-var import_node_fs11 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path12 = require("path");
 init_dist2();
 function getVariables(doc) {
   const variables = doc.variables ?? {};
@@ -4512,10 +5314,10 @@ function formatVariables(info) {
   return lines.join("\n");
 }
 function readAndParse8(file) {
-  const absPath = (0, import_node_path11.resolve)(file);
+  const absPath = (0, import_node_path12.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs11.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs12.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -4539,8 +5341,8 @@ function variablesCommand(program) {
 }
 
 // src/lib/video-project.ts
-var import_node_fs12 = require("fs");
-var import_node_path12 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_path13 = require("path");
 var VIDEO_PROJECT_VERSION = "1.0";
 var VIDEO_CUTLIST_VERSION = "1.1";
 var VIDEO_TRANSCRIPT_VERSION = "1.1";
@@ -4551,24 +5353,24 @@ function effectiveSpan(cut, duration) {
   };
 }
 async function createVideoProject(srcPath, destDir) {
-  const absSrc = (0, import_node_path12.resolve)(srcPath);
-  const ext = (0, import_node_path12.extname)(absSrc);
-  const stem = (0, import_node_path12.basename)(absSrc, ext);
-  const projectDir = destDir ? (0, import_node_path12.resolve)(destDir) : (0, import_node_path12.join)((0, import_node_path12.resolve)(absSrc, ".."), stem);
-  if (!(0, import_node_fs12.existsSync)(projectDir)) {
-    (0, import_node_fs12.mkdirSync)(projectDir, { recursive: true });
+  const absSrc = (0, import_node_path13.resolve)(srcPath);
+  const ext = (0, import_node_path13.extname)(absSrc);
+  const stem = (0, import_node_path13.basename)(absSrc, ext);
+  const projectDir = destDir ? (0, import_node_path13.resolve)(destDir) : (0, import_node_path13.join)((0, import_node_path13.resolve)(absSrc, ".."), stem);
+  if (!(0, import_node_fs13.existsSync)(projectDir)) {
+    (0, import_node_fs13.mkdirSync)(projectDir, { recursive: true });
   }
   const sourceFilename = `source${ext}`;
-  const sourcePath = (0, import_node_path12.join)(projectDir, sourceFilename);
-  if (!(0, import_node_fs12.existsSync)(sourcePath)) {
-    (0, import_node_fs12.copyFileSync)(absSrc, sourcePath);
+  const sourcePath = (0, import_node_path13.join)(projectDir, sourceFilename);
+  if (!(0, import_node_fs13.existsSync)(sourcePath)) {
+    (0, import_node_fs13.copyFileSync)(absSrc, sourcePath);
   }
-  const compositionPath = (0, import_node_path12.join)(projectDir, "project.atelier");
-  const transcriptPath = (0, import_node_path12.join)(projectDir, "transcript.json");
-  const cutsPath = (0, import_node_path12.join)(projectDir, "cuts.json");
-  const exportDir = (0, import_node_path12.join)(projectDir, "export");
-  if (!(0, import_node_fs12.existsSync)(exportDir)) {
-    (0, import_node_fs12.mkdirSync)(exportDir, { recursive: true });
+  const compositionPath = (0, import_node_path13.join)(projectDir, "project.atelier");
+  const transcriptPath = (0, import_node_path13.join)(projectDir, "transcript.json");
+  const cutsPath = (0, import_node_path13.join)(projectDir, "cuts.json");
+  const exportDir = (0, import_node_path13.join)(projectDir, "export");
+  if (!(0, import_node_fs13.existsSync)(exportDir)) {
+    (0, import_node_fs13.mkdirSync)(exportDir, { recursive: true });
   }
   const manifest = {
     source: sourceFilename,
@@ -4587,7 +5389,7 @@ async function createVideoProject(srcPath, destDir) {
       src: {
         type: "video",
         src: sourceFilename,
-        description: `Source: ${(0, import_node_path12.basename)(absSrc)}`
+        description: `Source: ${(0, import_node_path13.basename)(absSrc)}`
       }
     },
     layers: [
@@ -4613,16 +5415,16 @@ async function createVideoProject(srcPath, destDir) {
       }
     }
   };
-  if (!(0, import_node_fs12.existsSync)(compositionPath)) {
-    (0, import_node_fs12.writeFileSync)(compositionPath, JSON.stringify(draft, null, 2), "utf-8");
+  if (!(0, import_node_fs13.existsSync)(compositionPath)) {
+    (0, import_node_fs13.writeFileSync)(compositionPath, JSON.stringify(draft, null, 2), "utf-8");
   }
   const initialCuts = {
     version: VIDEO_CUTLIST_VERSION,
     source: sourceFilename,
     cuts: []
   };
-  if (!(0, import_node_fs12.existsSync)(cutsPath)) {
-    (0, import_node_fs12.writeFileSync)(cutsPath, JSON.stringify(initialCuts, null, 2), "utf-8");
+  if (!(0, import_node_fs13.existsSync)(cutsPath)) {
+    (0, import_node_fs13.writeFileSync)(cutsPath, JSON.stringify(initialCuts, null, 2), "utf-8");
   }
   return {
     dir: projectDir,
@@ -4635,11 +5437,11 @@ async function createVideoProject(srcPath, destDir) {
   };
 }
 function loadVideoProject(dir) {
-  const projectDir = (0, import_node_path12.resolve)(dir);
+  const projectDir = (0, import_node_path13.resolve)(dir);
   const possibleExts = [".mp4", ".mov", ".webm", ".mkv", ".avi"];
   let sourceFilename = "source.mp4";
   for (const ext of possibleExts) {
-    if ((0, import_node_fs12.existsSync)((0, import_node_path12.join)(projectDir, `source${ext}`))) {
+    if ((0, import_node_fs13.existsSync)((0, import_node_path13.join)(projectDir, `source${ext}`))) {
       sourceFilename = `source${ext}`;
       break;
     }
@@ -4655,19 +5457,19 @@ function loadVideoProject(dir) {
   };
   return {
     dir: projectDir,
-    sourcePath: (0, import_node_path12.join)(projectDir, sourceFilename),
-    compositionPath: (0, import_node_path12.join)(projectDir, "project.atelier"),
-    transcriptPath: (0, import_node_path12.join)(projectDir, "transcript.json"),
-    cutsPath: (0, import_node_path12.join)(projectDir, "cuts.json"),
-    exportDir: (0, import_node_path12.join)(projectDir, "export"),
+    sourcePath: (0, import_node_path13.join)(projectDir, sourceFilename),
+    compositionPath: (0, import_node_path13.join)(projectDir, "project.atelier"),
+    transcriptPath: (0, import_node_path13.join)(projectDir, "transcript.json"),
+    cutsPath: (0, import_node_path13.join)(projectDir, "cuts.json"),
+    exportDir: (0, import_node_path13.join)(projectDir, "export"),
     manifest
   };
 }
 function readCutList(project) {
-  if (!(0, import_node_fs12.existsSync)(project.cutsPath)) {
+  if (!(0, import_node_fs13.existsSync)(project.cutsPath)) {
     return { version: VIDEO_CUTLIST_VERSION, source: project.manifest.source, cuts: [] };
   }
-  const raw = JSON.parse((0, import_node_fs12.readFileSync)(project.cutsPath, "utf-8"));
+  const raw = JSON.parse((0, import_node_fs13.readFileSync)(project.cutsPath, "utf-8"));
   const cuts = raw.cuts.map((entry) => {
     if ("rawStart" in entry) return entry;
     return {
@@ -4686,11 +5488,11 @@ function readCutList(project) {
 }
 function writeCutList(project, cuts) {
   const payload = { ...cuts, version: VIDEO_CUTLIST_VERSION };
-  (0, import_node_fs12.writeFileSync)(project.cutsPath, JSON.stringify(payload, null, 2), "utf-8");
+  (0, import_node_fs13.writeFileSync)(project.cutsPath, JSON.stringify(payload, null, 2), "utf-8");
 }
 function readTranscript(project) {
-  if (!(0, import_node_fs12.existsSync)(project.transcriptPath)) return null;
-  const raw = JSON.parse((0, import_node_fs12.readFileSync)(project.transcriptPath, "utf-8"));
+  if (!(0, import_node_fs13.existsSync)(project.transcriptPath)) return null;
+  const raw = JSON.parse((0, import_node_fs13.readFileSync)(project.transcriptPath, "utf-8"));
   const segments = raw.segments.map((seg) => ({
     text: seg.text,
     start: seg.start,
@@ -4714,13 +5516,13 @@ function readTranscript(project) {
 }
 function writeTranscript(project, transcript) {
   const payload = { ...transcript, version: VIDEO_TRANSCRIPT_VERSION };
-  (0, import_node_fs12.writeFileSync)(project.transcriptPath, JSON.stringify(payload, null, 2), "utf-8");
+  (0, import_node_fs13.writeFileSync)(project.transcriptPath, JSON.stringify(payload, null, 2), "utf-8");
 }
 function readComposition(project) {
-  return JSON.parse((0, import_node_fs12.readFileSync)(project.compositionPath, "utf-8"));
+  return JSON.parse((0, import_node_fs13.readFileSync)(project.compositionPath, "utf-8"));
 }
 function writeComposition(project, doc) {
-  (0, import_node_fs12.writeFileSync)(project.compositionPath, JSON.stringify(doc, null, 2), "utf-8");
+  (0, import_node_fs13.writeFileSync)(project.compositionPath, JSON.stringify(doc, null, 2), "utf-8");
 }
 function rewriteCutLayers(doc, cuts, sourceFilename, sourceDuration, assetId = "src") {
   const preserved = doc.layers.filter((l) => !(l.tags ?? []).includes("silence-trim"));
@@ -4817,7 +5619,7 @@ function parseSilenceDetectStderr(stderr) {
   return intervals;
 }
 function runCapture(cmd, args) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve28, reject) => {
     const proc = (0, import_node_child_process2.spawn)(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     proc.stdout.on("data", (b) => stdout += b.toString());
@@ -4831,12 +5633,12 @@ function runCapture(cmd, args) {
     });
     proc.on("close", (code) => {
       if (code !== 0) reject(new Error(`${cmd} exited ${code}`));
-      else resolve14(stdout);
+      else resolve28(stdout);
     });
   });
 }
 function runCaptureStderr(cmd, args) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve28, reject) => {
     const proc = (0, import_node_child_process2.spawn)(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     proc.stderr.on("data", (b) => stderr += b.toString());
@@ -4848,7 +5650,7 @@ function runCaptureStderr(cmd, args) {
         reject(err);
       }
     });
-    proc.on("close", () => resolve14(stderr));
+    proc.on("close", () => resolve28(stderr));
   });
 }
 
@@ -5053,38 +5855,155 @@ function trimCommand(program) {
 
 // src/lib/whisper.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
+var import_node_path14 = require("path");
+var import_node_os2 = require("os");
+var import_promises = require("stream/promises");
+var import_node_stream = require("stream");
 async function probeWhisper() {
   if (await commandExists("whisper-cli")) return "whisper-cpp";
   if (process.env.OPENAI_API_KEY) return "openai-api";
   return "none";
 }
-async function runWhisperCpp(sourcePath, options = {}) {
-  const model = options.modelPath ?? options.model ?? "base.en";
-  const args = [
-    sourcePath,
-    "--model",
-    model,
-    "--output-json",
-    "--word-thold",
-    "0.01",
-    // emit word-level timestamps
-    "--print-progress",
-    "false"
-  ];
-  if (options.language) {
-    args.push("--language", options.language);
+function whisperCacheDir() {
+  return (0, import_node_path14.join)((0, import_node_os2.homedir)(), ".cache", "whisper.cpp", "models");
+}
+function modelCachePath(model) {
+  return (0, import_node_path14.join)(whisperCacheDir(), `ggml-${model}.bin`);
+}
+async function resolveWhisperModelPath(model, onProgress) {
+  if ((0, import_node_path14.isAbsolute)(model)) {
+    if (!(0, import_node_fs14.existsSync)(model)) {
+      throw new Error(`whisper model file not found at absolute path: ${model}`);
+    }
+    return model;
+  }
+  const cached = modelCachePath(model);
+  if ((0, import_node_fs14.existsSync)(cached)) return cached;
+  await downloadWhisperModel(model, onProgress);
+  if (!(0, import_node_fs14.existsSync)(cached)) {
+    throw new Error(
+      `whisper model download appeared to succeed but the file is missing at ${cached}`
+    );
   }
-  return runCaptureStdout("whisper-cli", args);
+  return cached;
 }
-function parseWhisperCppJson(jsonStr) {
-  const raw = JSON.parse(jsonStr);
-  const segments = (raw.transcription ?? []).map((seg) => {
-    const segStart = (seg.offsets?.from ?? 0) / 1e3;
-    const segEnd = (seg.offsets?.to ?? 0) / 1e3;
-    const segText = seg.text.trim();
-    let words;
-    if (seg.tokens && seg.tokens.length > 0) {
+async function downloadWhisperModel(model, onProgress) {
+  const dir = whisperCacheDir();
+  if (!(0, import_node_fs14.existsSync)(dir)) (0, import_node_fs14.mkdirSync)(dir, { recursive: true });
+  const dest = modelCachePath(model);
+  const url = `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-${model}.bin`;
+  const partPath = `${dest}.part`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(
+      `failed to download whisper model "${model}" (HTTP ${res.status} ${res.statusText}) from ${url} \u2014 check the model name`
+    );
+  }
+  if (!res.body) {
+    throw new Error(`whisper model download produced no body (model: ${model})`);
+  }
+  const totalHeader = res.headers.get("content-length");
+  const total = totalHeader ? parseInt(totalHeader, 10) : null;
+  let received = 0;
+  const nodeStream = import_node_stream.Readable.fromWeb(res.body);
+  nodeStream.on("data", (chunk) => {
+    received += chunk.length;
+    if (onProgress) onProgress(received, total);
+  });
+  await (0, import_promises.pipeline)(nodeStream, (0, import_node_fs14.createWriteStream)(partPath));
+  const { renameSync, unlinkSync: unlinkSync2 } = await import("fs");
+  if ((0, import_node_fs14.existsSync)(dest)) {
+    try {
+      unlinkSync2(dest);
+    } catch {
+    }
+  }
+  renameSync(partPath, dest);
+  return dest;
+}
+async function runWhisperCpp(sourcePath, options = {}) {
+  const modelName = options.modelPath ?? options.model ?? "base.en";
+  const resolvedModelPath = await resolveWhisperModelPath(modelName, options.onProgress);
+  const { audioPath, tempDir } = await extractAudioForWhisper(sourcePath);
+  try {
+    const args = [
+      audioPath,
+      "--model",
+      resolvedModelPath,
+      "--output-json-full",
+      // word-level timestamps in the JSON output
+      "--word-thold",
+      "0.01",
+      "--print-progress",
+      "false"
+    ];
+    if (options.language) {
+      args.push("--language", options.language);
+    }
+    const stdout = await runCaptureStdout("whisper-cli", args);
+    const jsonSidecar = `${audioPath}.json`;
+    if ((0, import_node_fs14.existsSync)(jsonSidecar)) {
+      return (0, import_node_fs14.readFileSync)(jsonSidecar, "utf-8");
+    }
+    return stdout;
+  } finally {
+    if (tempDir) {
+      try {
+        (0, import_node_fs14.rmSync)(tempDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+async function extractAudioForWhisper(sourcePath) {
+  const lower = sourcePath.toLowerCase();
+  if (lower.endsWith(".wav")) return { audioPath: sourcePath, tempDir: null };
+  if (!await commandExists("ffmpeg")) {
+    throw new Error(
+      `ffmpeg not found on PATH. Whisper.cpp only ingests WAV; non-WAV sources (${sourcePath}) need ffmpeg to extract audio. Install with: brew install ffmpeg.`
+    );
+  }
+  const tempDir = (0, import_node_fs14.mkdtempSync)((0, import_node_path14.join)((0, import_node_os2.tmpdir)(), "atelier-whisper-"));
+  const audioPath = (0, import_node_path14.join)(tempDir, "audio.wav");
+  await runOk("ffmpeg", [
+    "-loglevel",
+    "error",
+    "-y",
+    "-i",
+    sourcePath,
+    "-ar",
+    "16000",
+    "-ac",
+    "1",
+    "-c:a",
+    "pcm_s16le",
+    audioPath
+  ]);
+  return { audioPath, tempDir };
+}
+async function runOk(cmd, args) {
+  return new Promise((resolve28, reject) => {
+    const p = (0, import_node_child_process3.spawn)(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    p.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    p.on("error", reject);
+    p.on("close", (code) => {
+      if (code === 0) resolve28();
+      else reject(new Error(`${cmd} exited ${code}: ${stderr.trim() || "(no stderr)"}`));
+    });
+  });
+}
+function parseWhisperCppJson(jsonStr) {
+  const raw = JSON.parse(jsonStr);
+  const segments = (raw.transcription ?? []).map((seg) => {
+    const segStart = (seg.offsets?.from ?? 0) / 1e3;
+    const segEnd = (seg.offsets?.to ?? 0) / 1e3;
+    const segText = seg.text.trim();
+    let words;
+    if (seg.tokens && seg.tokens.length > 0) {
       words = seg.tokens.filter((t) => t.text.trim().length > 0 && !t.text.startsWith("[_")).map((t) => ({
         detected: t.text.trim(),
         text: t.text.trim(),
@@ -5118,18 +6037,18 @@ function parseWhisperCppJson(jsonStr) {
 }
 async function commandExists(name) {
   if (name.startsWith("/") || name.match(/^[A-Z]:\\/)) {
-    return (0, import_node_fs13.existsSync)(name);
+    return (0, import_node_fs14.existsSync)(name);
   }
-  return new Promise((resolve14) => {
+  return new Promise((resolve28) => {
     const probe = (0, import_node_child_process3.spawn)(process.platform === "win32" ? "where" : "which", [name], {
       stdio: ["ignore", "ignore", "ignore"]
     });
-    probe.on("error", () => resolve14(false));
-    probe.on("close", (code) => resolve14(code === 0));
+    probe.on("error", () => resolve28(false));
+    probe.on("close", (code) => resolve28(code === 0));
   });
 }
 function runCaptureStdout(cmd, args) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve28, reject) => {
     const proc = (0, import_node_child_process3.spawn)(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -5150,13 +6069,16 @@ function runCaptureStdout(cmd, args) {
         reject(new Error(`${cmd} exited ${code}
 ${stderr}`));
       } else {
-        resolve14(stdout);
+        resolve28(stdout);
       }
     });
   });
 }
 
 // src/lib/transcript-model.ts
+var import_node_crypto = require("crypto");
+var import_node_fs15 = require("fs");
+var import_node_path15 = require("path");
 var DEFAULT_TRANSCRIPT_MATCH_TOLERANCE = 0.3;
 var DEFAULT_PHRASE_MAX_WORDS = 5;
 var DEFAULT_PHRASE_PAUSE_GAP_SECONDS = 0.4;
@@ -5452,13 +6374,24 @@ 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);
+  const phraseFrames = Math.max(1, endFrame - startFrame);
+  const fadeInFrames = Math.min(fadeFrames, Math.floor(phraseFrames / 2));
+  const fadeOutStart = Math.max(startFrame + fadeInFrames, endFrame - fadeFrames);
   return [
-    // Fade in to visible at phrase start
+    // Fade in AT phrase start (the [start, start+fadeF] window lives INSIDE
+    // the phrase). Previously this was [start - fadeF, start], which placed
+    // the fade-in BEFORE the phrase began — for touching transcript phrases
+    // (end_N === start_{N+1}, the common case), cap-N's fade-out [end-2, end]
+    // and cap-(N+1)'s fade-in [start-2, start] overlapped on the same frame
+    // window, producing a visible 2-frame cross-fade where both captions
+    // rendered at ~0.68 opacity simultaneously (the "captions stacking"
+    // false-bug report L-2026-05-28-ascend-151000-001). Moving the fade-in
+    // INSIDE the phrase means cap-N fades out [88, 90] → cap-(N+1) fades in
+    // [90, 92], no overlap, captions transition discretely.
     {
       layer: layerId,
       property: "opacity",
-      range: [Math.max(0, startFrame - fadeFrames), startFrame],
+      range: [startFrame, startFrame + fadeInFrames],
       from: 0,
       to: 1,
       easing: "ease-out"
@@ -5491,8 +6424,10 @@ async function transcribeProject(projectDir, options = {}) {
       "OpenAI API backend is not yet implemented. Install whisper.cpp for local transcription."
     );
   }
-  const rawJson = await runWhisperCpp(project.sourcePath, {
+  const sourcePath = options.sourcePath ?? project.sourcePath;
+  const rawJson = await runWhisperCpp(sourcePath, {
     model: options.model,
+    modelPath: options.modelPath,
     language: options.language
   });
   let transcript = parseWhisperCppJson(rawJson);
@@ -5538,10 +6473,11 @@ function formatResult2(result) {
 function transcribeCommand(program) {
   program.command("transcribe <project>").description(
     "Transcribe source video via Whisper, write transcript.json, and rewrite caption-tagged TextVisual layers in project.atelier. Preserves user transcript edits on re-run."
-  ).option("--model <name>", "Whisper model: tiny|base|small|medium|large-v3", "base.en").option("--language <code>", "BCP-47 language hint (omit for autodetect)").option("--reset", "Discard existing user edits; full fresh transcript").option("--no-captions", "Write transcript.json only; skip caption layer generation").option("--recipe <name>", "Apply a Studio Recipe's caption_style + caption_grouping").option("--dry-run", "Print transcript; don't write files").option("--json", "Output result as JSON for piping").action(async (project, opts) => {
+  ).option("--model <name>", "Whisper model: tiny|base|small|medium|large-v3", "base.en").option("--model-path <path>", "Explicit path to a .bin model file (overrides --model)").option("--language <code>", "BCP-47 language hint (omit for autodetect)").option("--reset", "Discard existing user edits; full fresh transcript").option("--no-captions", "Write transcript.json only; skip caption layer generation").option("--recipe <name>", "Apply a Studio Recipe's caption_style + caption_grouping").option("--dry-run", "Print transcript; don't write files").option("--json", "Output result as JSON for piping").action(async (project, opts) => {
     try {
       let transcribeOpts = {
         model: opts.model,
+        modelPath: opts.modelPath,
         language: opts.language,
         reset: opts.reset,
         noCaptions: !opts.captions,
@@ -5719,25 +6655,25 @@ function captionsCommand(program) {
 }
 
 // src/commands/recipe.ts
-var import_node_fs14 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path16 = require("path");
 function recipeCommand(program) {
   const recipe = program.command("recipe").description("Manage Studio Recipes \u2014 reusable style presets");
   recipe.command("new <name>").description("Scaffold a starter recipe YAML with all current defaults filled in").option("--dir <path>", "Where to write the recipe (default: ./.atelier/recipes/)").action((name, opts) => {
     try {
-      const baseDir = opts.dir ?? (0, import_node_path13.join)((0, import_node_path13.resolve)(process.cwd()), ".atelier", "recipes");
-      if (!(0, import_node_fs14.existsSync)(baseDir)) {
-        (0, import_node_fs14.mkdirSync)(baseDir, { recursive: true });
+      const baseDir = opts.dir ?? (0, import_node_path16.join)((0, import_node_path16.resolve)(process.cwd()), ".atelier", "recipes");
+      if (!(0, import_node_fs16.existsSync)(baseDir)) {
+        (0, import_node_fs16.mkdirSync)(baseDir, { recursive: true });
       }
       const hasKnownExt = /\.(recipe\.yaml|recipe\.json|yaml|yml|json)$/i.test(name);
       const fileName = hasKnownExt ? name : `${name}.recipe.yaml`;
-      const outPath = (0, import_node_path13.join)(baseDir, fileName);
-      if ((0, import_node_fs14.existsSync)(outPath)) {
+      const outPath = (0, import_node_path16.join)(baseDir, fileName);
+      if ((0, import_node_fs16.existsSync)(outPath)) {
         throw new Error(`Recipe already exists at ${outPath} \u2014 refusing to overwrite.`);
       }
       const recipeName = name.replace(/\.(recipe\.yaml|recipe\.json|yaml|yml|json)$/i, "");
       const yaml = scaffoldRecipeYaml(recipeName);
-      (0, import_node_fs14.writeFileSync)(outPath, yaml, "utf-8");
+      (0, import_node_fs16.writeFileSync)(outPath, yaml, "utf-8");
       console.log(`Created ${outPath}`);
     } catch (err) {
       console.error(`atelier recipe new: ${err instanceof Error ? err.message : err}`);
@@ -5824,9 +6760,2018 @@ Done.`);
     }
   });
 }
+
+// src/commands/init.ts
+var import_node_child_process4 = require("child_process");
+var import_node_fs22 = require("fs");
+var import_node_path22 = require("path");
+var import_node_readline = require("readline");
+
+// src/commands/artifacts.ts
+var import_node_path18 = require("path");
+var import_node_fs18 = require("fs");
+
+// src/lib/artifact-project.ts
+var import_node_fs17 = require("fs");
+var import_node_path17 = require("path");
+var ARTIFACT_FILENAMES = {
+  design: "DESIGN.md",
+  script: "SCRIPT.md",
+  storyboard: "STORYBOARD.md"
+};
+function loadArtifactsFromProject(projectDir) {
+  const absDir = (0, import_node_path17.resolve)(projectDir);
+  if (!(0, import_node_fs17.existsSync)(absDir)) {
+    throw new Error(`project directory does not exist: ${absDir}`);
+  }
+  const stat = (0, import_node_fs17.statSync)(absDir);
+  if (!stat.isDirectory()) {
+    throw new Error(`project path is not a directory: ${absDir}`);
+  }
+  const result = {
+    projectDir: absDir,
+    missing: [],
+    parseErrors: []
+  };
+  for (const slot of ["design", "script", "storyboard"]) {
+    const filename = ARTIFACT_FILENAMES[slot];
+    const filePath = (0, import_node_path17.join)(absDir, filename);
+    if (!(0, import_node_fs17.existsSync)(filePath)) {
+      result.missing.push(filename);
+      continue;
+    }
+    let raw;
+    try {
+      raw = (0, import_node_fs17.readFileSync)(filePath, "utf-8");
+    } catch (err) {
+      result.parseErrors.push({
+        artifact: slot,
+        file: filePath,
+        message: `read failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+      continue;
+    }
+    try {
+      if (slot === "design") {
+        result.design = parseDesign(raw);
+      } else if (slot === "script") {
+        result.script = parseScript(raw);
+      } else {
+        result.storyboard = parseStoryboard(raw);
+      }
+    } catch (err) {
+      result.parseErrors.push({
+        artifact: slot,
+        file: filePath,
+        message: formatParseError(err)
+      });
+    }
+  }
+  return result;
+}
+function formatParseError(err) {
+  if (err instanceof Error) {
+    const issues = err.issues;
+    if (Array.isArray(issues) && issues.length > 0) {
+      const formatted = issues.map((issue) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+        return `${path}: ${issue.message}`;
+      }).join("; ");
+      return formatted;
+    }
+    return err.message;
+  }
+  return String(err);
+}
+
+// src/lib/artifact-templates.ts
+var DESIGN_TEMPLATE = `---
+# DESIGN.md \u2014 brand register for this Project.
+# Authored by Quill. Replace the TODO values with the real ones, then run
+# \`atelier artifacts validate <project-dir>\` to check the result.
+
+audience:
+  # TODO: who is this for? Be specific \u2014 a single sentence's worth of person.
+  primary: TODO describe primary audience
+  # TODO: optional second-order audience (lurkers, decision-makers, etc.)
+  # secondary: TODO secondary audience
+  # TODO: where this ships. Closed-ish list; common values: linkedin, x, instagram, youtube-shorts, tiktok.
+  platform: [TODO-platform]
+
+voice:
+  # TODO: 3 to 5 voice descriptors. Examples: dry, precise, mischievous, warm, clinical, contrarian.
+  descriptors: [TODO-descriptor-1, TODO-descriptor-2, TODO-descriptor-3]
+  # TODO: optional reference voices (writers, speakers, channels). Anchors the tone.
+  # references: [TODO reference]
+
+visual_register:
+  palette:
+    # TODO: replace these defaults with your real brand tokens.
+    # Roles are closed: background | surface | primary | accent | text-on-dark | text-on-light.
+    # Hex must be #RGB / #RRGGBB / #RRGGBBAA.
+    - { token: paper,  hex: "#F4EFE6", role: background }
+    - { token: ink,    hex: "#1A1A1A", role: text-on-light }
+    - { token: accent, hex: "#C9533C", role: accent }
+  typography:
+    # TODO: real font tokens. Usage is closed: display | body | caption | mono.
+    - { token: display, family: "TODO-display-family", weights: [400, 700], usage: display }
+    - { token: body,    family: "TODO-body-family",    weights: [400, 500], usage: body }
+  motion_register:
+    # tempo:        snappy | steady | calm | languid
+    # easing_bias:  linear | ease-out | spring
+    # camera_bias:  static | drift | snap   (optional)
+    tempo: steady
+    easing_bias: ease-out
+    camera_bias: static
+
+constraints:
+  # TODO: optional max duration in seconds (omit if no hard cap).
+  # max_duration_seconds: 75
+  # TODO: closed aspect-ratio set: 9:16 | 1:1 | 16:9 | 4:5.
+  aspect_ratios: ["9:16"]
+  # TODO: prose rules Iris must honor at composition time. Free-text strings.
+  do_not:
+    - TODO add a do-not rule
+
+brand_references:
+  logos:
+    # TODO: at least one logo token. Role is closed: primary | mark | wordmark.
+    - { token: mark-primary, role: mark }
+  # TODO: optional social handles.
+  # handles:
+  #   - { platform: x, value: "@your-handle" }
+  # TODO: optional page-number convention used in carousel exports.
+  # page_number_convention: "n / N, bottom-right, body font, 60% opacity"
+
+# variances:  # only populate when this Project diverges from an attached recipe.
+#   - { field: visual_register.palette.accent, value: "#FF0000", reason: "campaign override" }
+---
+
+# Voice notes
+
+<!--
+  Free-form prose. Quill's notes on rhythm, signature phrases, taboos.
+  This body is preserved verbatim \u2014 Iris does not parse it; it's for humans
+  and for the next pass of Quill.
+-->
+
+> TODO: a paragraph or two on how the voice should *feel*. Punchy openings?
+> One idea per beat? Reserve the accent color for the most important word?
+`;
+var SCRIPT_TEMPLATE = `---
+# SCRIPT.md \u2014 narrative for this Project.
+# Authored by Quill, refined by Lux. Replace TODO copy with the real line.
+# Beat ids are kebab-case and must match the STORYBOARD beat ids.
+
+mode: narrated            # narrated | carousel | text-only
+target_duration_s: 60     # creator intent; transcript binding can rebind beat windows post-VO
+language: en-US
+# tts_voice: voice.host.primary   # optional slot ref; resolved at TTS time
+---
+
+# Hook
+# At least one beat. The hook earns the rest of the watch.
+- id: hook-1
+  copy: "TODO: contrarian opener \u2014 one sentence that earns the next beat."
+  intent: "TODO why this opener works (one sentence)."
+  est_duration_s: 3.0
+  bind_to_transcript: true
+
+# Story
+# Optional block; remove if not used. Establish receipts.
+- id: story-1
+  copy: "TODO: who you are / why this is credible \u2014 one sentence."
+  intent: "TODO establish receipts; promise specificity."
+  est_duration_s: 3.0
+  bind_to_transcript: true
+
+# Proof
+# Optional block; remove if not used. Concrete claims.
+- id: proof-1
+  copy: "TODO: the most defensible claim, stated plainly."
+  intent: "TODO lead with what you can defend hardest."
+  est_duration_s: 3.0
+  bind_to_transcript: true
+
+# CTA
+# At least one beat. Single token call-to-action; no verb pileup.
+- id: cta-1
+  copy: "TODO: link in bio. / one short ask."
+  intent: "TODO the single action you want from the viewer."
+  est_duration_s: 2.0
+  bind_to_transcript: true
+`;
+var STORYBOARD_TEMPLATE = `---
+# STORYBOARD.md \u2014 composition beats for this Project.
+# Authored by Lux. One beat per SCRIPT beat (plus optional b-roll.* beats).
+# Iris walks this file beat by beat to mutate the live AtelierDocument.
+
+technique_library_version: 1     # bump on additive technique-library changes
+aspect_ratio: "9:16"             # closed: 9:16 | 1:1 | 16:9 | 4:5
+---
+
+## hook-1
+# TODO: matches SCRIPT beat \`hook-1\`. Tune mood / camera / slots to match the line.
+window: { start_s: 0.0, end_s: 3.0 }
+mood: [clinical]                 # adjectives; closed-ish vocab \u2014 tense, warm, clinical, mischievous, ...
+camera: { kind: static }         # kind: static | drift | push | pull | whip
+slots:
+  # Typed slot refs: <kind>.<category>.<specifier>.
+  # Kind is closed (image | video | audio | text | font | voice | logo).
+  # \`text.super.from-script\` pulls copy from the matching SCRIPT beat.
+  - text.super.from-script
+techniques:
+  # Must exist in the active technique library (technique_library_version).
+  # v1 set: text.split-reveal, image.ken-burns.slow, super.weight-pulse-on-keyword, background.color-shift-to-token.
+  - text.split-reveal
+transition_out: { kind: cut }    # kind: cut | dip-to-color | whip | crossfade
+# sfx:
+#   - { slot: audio.sfx.transition.whoosh, gain_db: -6 }
+
+## cta-1
+# TODO: matches SCRIPT beat \`cta-1\`. Final beat \u2014 keep it clean.
+window: { start_s: 3.0, end_s: 5.0 }
+mood: [grounded]
+camera: { kind: static }
+slots:
+  - text.super.from-script
+techniques:
+  - text.split-reveal
+transition_out: { kind: cut }
+
+# TODO: add \`## story-1\`, \`## proof-1\`, etc. once Quill writes the matching SCRIPT beats.
+# Storyboard-only b-roll beats are also allowed; prefix the id with \`b-roll.\`:
+#
+# ## b-roll.intro-monitor
+# window: { start_s: 1.0, end_s: 2.0 }
+# mood: [clinical]
+# camera: { kind: drift }
+# slots:
+#   - image.b-roll.code-monitor
+# techniques:
+#   - image.ken-burns.slow
+# transition_out: { kind: crossfade, duration_s: 0.2 }
+`;
+var ARTIFACT_TEMPLATES = {
+  design: { filename: "DESIGN.md", content: DESIGN_TEMPLATE },
+  script: { filename: "SCRIPT.md", content: SCRIPT_TEMPLATE },
+  storyboard: { filename: "STORYBOARD.md", content: STORYBOARD_TEMPLATE }
+};
+var ARTIFACT_SLOTS = ["design", "script", "storyboard"];
+
+// src/commands/artifacts.ts
+function artifactsCommand(program) {
+  const artifacts = program.command("artifacts").description("Manage Atelier front-of-pipeline artifacts (DESIGN/SCRIPT/STORYBOARD)");
+  artifacts.command("validate <project-dir>").description(
+    "Validate the DESIGN.md / SCRIPT.md / STORYBOARD.md triplet inside a Project directory. Runs the ^valid-artifact-set gate; absent artifacts are noted, not failed."
+  ).option("--json", "Emit a machine-readable JSON report instead of human-formatted output").action((projectDir, opts) => {
+    let loaded;
+    try {
+      loaded = loadArtifactsFromProject(projectDir);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+      } else {
+        console.error(`atelier artifacts validate: ${msg}`);
+      }
+      process.exit(1);
+    }
+    const validation = validateArtifactSet({
+      design: loaded.design,
+      script: loaded.script,
+      storyboard: loaded.storyboard
+    });
+    const hasParseErrors = loaded.parseErrors.length > 0;
+    const ok = !hasParseErrors && validation.ok;
+    if (opts.json) {
+      emitJson(loaded, validation, ok);
+    } else {
+      emitHuman(loaded, validation, ok);
+    }
+    if (!ok) {
+      process.exit(1);
+    }
+  });
+  artifacts.command("scaffold <project-dir>").description(
+    "Write canonical empty DESIGN.md / SCRIPT.md / STORYBOARD.md templates into a Project directory. Creates the directory if absent; refuses to overwrite existing files without --force."
+  ).option(
+    "--only <slots>",
+    "Restrict to a subset (design | script | storyboard); comma-separated or repeated flag.",
+    collectOnly,
+    []
+  ).option("--force", "Overwrite existing artifact files in <project-dir>").option("--json", "Emit a machine-readable JSON report instead of human-formatted output").action((projectDir, opts) => {
+    try {
+      const slots = resolveSlots(opts.only ?? []);
+      const result = scaffoldArtifacts(projectDir, {
+        slots,
+        force: opts.force === true
+      });
+      if (opts.json) {
+        console.log(JSON.stringify({
+          ok: true,
+          projectDir: result.projectDir,
+          created: result.created,
+          skipped: result.skipped
+        }, null, 2));
+      } else {
+        console.log(`Project: ${result.projectDir}`);
+        for (const c of result.created) console.log(`  Created  ${c}`);
+        for (const s of result.skipped) console.log(`  Skipped  ${s}  (already exists; use --force to overwrite)`);
+        console.log("");
+        console.log(
+          `Result: ${result.created.length} written, ${result.skipped.length} skipped.`
+        );
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+      } else {
+        console.error(`atelier artifacts scaffold: ${msg}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+function collectOnly(value, previous) {
+  const parts = value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return [...previous, ...parts];
+}
+function resolveSlots(raw) {
+  if (raw.length === 0) return [...ARTIFACT_SLOTS];
+  const seen = /* @__PURE__ */ new Set();
+  for (const token of raw) {
+    if (!isArtifactSlot(token)) {
+      throw new Error(
+        `unknown --only value "${token}" \u2014 expected one of ${ARTIFACT_SLOTS.join(", ")}`
+      );
+    }
+    seen.add(token);
+  }
+  return ARTIFACT_SLOTS.filter((s) => seen.has(s));
+}
+function isArtifactSlot(value) {
+  return ARTIFACT_SLOTS.includes(value);
+}
+function scaffoldArtifacts(projectDir, opts) {
+  const absDir = (0, import_node_path18.resolve)(projectDir);
+  if ((0, import_node_fs18.existsSync)(absDir)) {
+    const stat = (0, import_node_fs18.statSync)(absDir);
+    if (!stat.isDirectory()) {
+      throw new Error(`project path is not a directory: ${absDir}`);
+    }
+  } else {
+    (0, import_node_fs18.mkdirSync)(absDir, { recursive: true });
+  }
+  const targets = opts.slots.map((slot) => ({
+    slot,
+    filename: ARTIFACT_TEMPLATES[slot].filename,
+    abs: (0, import_node_path18.join)(absDir, ARTIFACT_TEMPLATES[slot].filename),
+    content: ARTIFACT_TEMPLATES[slot].content
+  }));
+  if (!opts.force) {
+    const clobbered = targets.filter((t) => (0, import_node_fs18.existsSync)(t.abs)).map((t) => t.abs);
+    if (clobbered.length > 0) {
+      throw new Error(
+        `refusing to overwrite existing file${clobbered.length === 1 ? "" : "s"} (use --force to replace): ${clobbered.join(", ")}`
+      );
+    }
+  }
+  const created = [];
+  const skipped = [];
+  for (const t of targets) {
+    if (!opts.force && (0, import_node_fs18.existsSync)(t.abs)) {
+      skipped.push(t.abs);
+      continue;
+    }
+    (0, import_node_fs18.writeFileSync)(t.abs, t.content, "utf-8");
+    created.push(t.abs);
+  }
+  return { projectDir: absDir, created, skipped };
+}
+function emitJson(loaded, validation, ok) {
+  const payload = {
+    ok,
+    projectDir: loaded.projectDir,
+    present: {
+      design: loaded.design !== void 0,
+      script: loaded.script !== void 0,
+      storyboard: loaded.storyboard !== void 0
+    },
+    missing: loaded.missing,
+    parseErrors: loaded.parseErrors.map((e) => ({
+      artifact: e.artifact,
+      file: e.file,
+      message: e.message
+    })),
+    validation: {
+      ok: validation.ok,
+      warnings: validation.warnings,
+      errors: validation.errors
+    }
+  };
+  console.log(JSON.stringify(payload, null, 2));
+}
+function emitHuman(loaded, validation, ok) {
+  console.log(`Project: ${loaded.projectDir}`);
+  for (const slot of ["design", "script", "storyboard"]) {
+    const filename = ARTIFACT_FILENAMES[slot];
+    const present = loaded[slot] !== void 0;
+    const parseErr = loaded.parseErrors.find((e) => e.artifact === slot);
+    if (parseErr) {
+      console.log(`  ${filename}  FAIL  (parse error)`);
+      console.log(`    ${formatRelativeFile(parseErr.file, loaded.projectDir)}: ${parseErr.message}`);
+    } else if (present) {
+      console.log(`  ${filename}  OK`);
+    } else {
+      console.log(`  ${filename}  [not present]`);
+    }
+  }
+  console.log("");
+  console.log("Cross-artifact validation:");
+  if (validation.errors.length === 0 && validation.warnings.length === 0) {
+    console.log("  PASS (no warnings, no errors)");
+  } else {
+    if (validation.errors.length > 0) {
+      console.log(`  Errors (${validation.errors.length}):`);
+      for (const e of validation.errors) {
+        console.log(`    - ${e}`);
+      }
+    }
+    if (validation.warnings.length > 0) {
+      console.log(`  Warnings (${validation.warnings.length}):`);
+      for (const w of validation.warnings) {
+        console.log(`    - ${w}`);
+      }
+    }
+  }
+  console.log("");
+  console.log(ok ? "Result: PASS" : "Result: FAIL");
+}
+function formatRelativeFile(file, projectDir) {
+  try {
+    const rel = (0, import_node_path18.relative)(projectDir, file);
+    return rel.length > 0 ? rel : file;
+  } catch {
+    return file;
+  }
+}
+
+// src/lib/learning-mode.ts
+var import_node_fs21 = require("fs");
+var import_node_path21 = require("path");
+
+// src/lib/workspace.ts
+var import_node_fs20 = require("fs");
+var import_node_path20 = require("path");
+
+// src/lib/paradigm-augment.ts
+var import_node_fs19 = require("fs");
+var import_node_path19 = require("path");
+
+// src/lib/workspace.ts
+var WORKSPACE_MANIFEST_FILENAME = "workspace.atelier";
+function findWorkspace(cwd) {
+  let dir = (0, import_node_path20.resolve)(cwd);
+  while (true) {
+    const candidate = (0, import_node_path20.join)(dir, WORKSPACE_MANIFEST_FILENAME);
+    if ((0, import_node_fs20.existsSync)(candidate)) {
+      const manifest = readWorkspace(dir);
+      return { workspaceDir: dir, manifest };
+    }
+    const parent = (0, import_node_path20.dirname)(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readWorkspace(workspaceDir) {
+  const absPath = (0, import_node_path20.join)((0, import_node_path20.resolve)(workspaceDir), WORKSPACE_MANIFEST_FILENAME);
+  if (!(0, import_node_fs20.existsSync)(absPath)) {
+    throw new Error(`workspace manifest not found: ${absPath}`);
+  }
+  const raw = (0, import_node_fs20.readFileSync)(absPath, "utf-8");
+  const parsed = parseWorkspaceYaml(raw);
+  const result = WorkspaceManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((issue) => {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+      return `${path}: ${issue.message}`;
+    }).join("; ");
+    throw new Error(`workspace.atelier at ${absPath} failed validation \u2014 ${issues}`);
+  }
+  return result.data;
+}
+function writeWorkspace(workspaceDir, manifest) {
+  const absDir = (0, import_node_path20.resolve)(workspaceDir);
+  if (!(0, import_node_fs20.existsSync)(absDir)) {
+    (0, import_node_fs20.mkdirSync)(absDir, { recursive: true });
+  }
+  const absPath = (0, import_node_path20.join)(absDir, WORKSPACE_MANIFEST_FILENAME);
+  (0, import_node_fs20.writeFileSync)(absPath, renderWorkspaceYaml(manifest), "utf-8");
+  return absPath;
+}
+function hasProjectMarker(dir) {
+  const abs = (0, import_node_path20.resolve)(dir);
+  if ((0, import_node_fs20.existsSync)((0, import_node_path20.join)(abs, "project.atelier"))) return true;
+  const dotAtelier = (0, import_node_path20.join)(abs, ".atelier");
+  if (!(0, import_node_fs20.existsSync)(dotAtelier)) return false;
+  try {
+    return (0, import_node_fs20.statSync)(dotAtelier).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function listProjects(workspaceDir) {
+  const absDir = (0, import_node_path20.resolve)(workspaceDir);
+  let entries;
+  try {
+    entries = (0, import_node_fs20.readdirSync)(absDir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    const full = (0, import_node_path20.join)(absDir, entry);
+    let st;
+    try {
+      st = (0, import_node_fs20.statSync)(full);
+    } catch {
+      continue;
+    }
+    if (!st.isDirectory()) continue;
+    if (hasProjectMarker(full)) {
+      out.push(entry);
+    }
+  }
+  return out.sort();
+}
+function renderWorkspaceYaml(manifest) {
+  const lines = [];
+  lines.push(`# Atelier workspace manifest.`);
+  lines.push(`# Created by \`atelier studio --new\`. Edit fields directly when needed.`);
+  lines.push(`# A workspace holds multiple Projects with shared learning mode + mind-map.`);
+  lines.push(`version: '${manifest.version}'`);
+  lines.push(`name: ${yamlScalar(manifest.name)}`);
+  lines.push(`created: '${manifest.created}'`);
+  lines.push(`default_mode: ${manifest.default_mode}`);
+  if (manifest.description !== void 0) {
+    lines.push(`description: ${yamlScalar(manifest.description)}`);
+  }
+  if (manifest.projects && manifest.projects.length > 0) {
+    lines.push(`projects:`);
+    for (const p of manifest.projects) {
+      lines.push(`  - ${yamlScalar(p)}`);
+    }
+  } else if (manifest.projects !== void 0) {
+    lines.push(`projects: []`);
+  }
+  return lines.join("\n") + "\n";
+}
+function parseWorkspaceYaml(raw) {
+  const fields = {};
+  let listKey = null;
+  let listItems = [];
+  const flushList = () => {
+    if (listKey !== null) {
+      fields[listKey] = listItems;
+      listKey = null;
+      listItems = [];
+    }
+  };
+  for (const rawLine of raw.split(/\r?\n/)) {
+    const lineNoComment = stripTrailingComment(rawLine);
+    if (lineNoComment.trim().length === 0) continue;
+    if (listKey !== null) {
+      const itemMatch = lineNoComment.match(/^\s+-\s+(.+?)\s*$/);
+      if (itemMatch) {
+        listItems.push(stripYamlScalar(itemMatch[1]));
+        continue;
+      }
+      flushList();
+    }
+    const kv = lineNoComment.match(/^([A-Za-z_][\w-]*)\s*:\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    const value = kv[2].trim();
+    if (value.length === 0) {
+      listKey = key;
+      listItems = [];
+      continue;
+    }
+    if (value === "[]") {
+      fields[key] = [];
+      continue;
+    }
+    fields[key] = stripYamlScalar(value);
+  }
+  flushList();
+  return fields;
+}
+function stripYamlScalar(value) {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+function yamlScalar(value) {
+  if (value.length === 0) return "''";
+  if (/^[\w./\- ]+$/.test(value) && !/^\s/.test(value) && !/\s$/.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function stripTrailingComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (c === "'" && !inDouble) inSingle = !inSingle;
+    else if (c === '"' && !inSingle) inDouble = !inDouble;
+    else if (c === "#" && !inSingle && !inDouble) return line.slice(0, i);
+  }
+  return line;
+}
+
+// src/lib/learning-mode.ts
+var LEARNING_MODES = ["ambient", "explicit"];
+var LEARNING_MODE_VERSION = "1.0";
+function learningModePath(projectDir) {
+  return (0, import_node_path21.join)((0, import_node_path21.resolve)(projectDir), ".atelier", "learning-mode.yaml");
+}
+function writeLearningMode(projectDir, mode, opts = {}) {
+  const absPath = learningModePath(projectDir);
+  const dir = (0, import_node_path21.dirname)(absPath);
+  if (!(0, import_node_fs21.existsSync)(dir)) {
+    (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
+  }
+  const ts = (opts.chosenAt ?? /* @__PURE__ */ new Date()).toISOString();
+  const content = renderLearningModeYaml({ version: LEARNING_MODE_VERSION, mode, chosen_at: ts });
+  (0, import_node_fs21.writeFileSync)(absPath, content, "utf-8");
+  return absPath;
+}
+function readLearningMode(projectDir) {
+  const absPath = learningModePath(projectDir);
+  if (!(0, import_node_fs21.existsSync)(absPath)) return void 0;
+  const raw = (0, import_node_fs21.readFileSync)(absPath, "utf-8");
+  const fields = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
+    const m = trimmed.match(/^([A-Za-z_][\w-]*)\s*:\s*(.+?)\s*$/);
+    if (!m) continue;
+    fields[m[1]] = stripYamlScalar2(m[2]);
+  }
+  const mode = fields.mode;
+  if (mode !== "ambient" && mode !== "explicit") {
+    throw new Error(
+      `learning-mode.yaml at ${absPath} has invalid mode "${mode ?? "<missing>"}" \u2014 expected one of ${LEARNING_MODES.join(", ")}`
+    );
+  }
+  const chosen_at = fields.chosen_at;
+  if (!chosen_at) {
+    throw new Error(`learning-mode.yaml at ${absPath} is missing chosen_at`);
+  }
+  return {
+    version: fields.version ?? LEARNING_MODE_VERSION,
+    mode,
+    chosen_at
+  };
+}
+function renderLearningModeYaml(file) {
+  return `# Atelier creator learning mode.
+# Set by \`atelier init\`. Change anytime by editing this file \u2014 the system
+# never auto-prompts to switch (TD-2026-05-26-646).
+version: '${file.version}'
+mode: ${file.mode}
+chosen_at: '${file.chosen_at}'
+`;
+}
+function stripYamlScalar2(value) {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+
+// src/commands/init.ts
+function initCommand(program) {
+  program.command("init <project-dir>").description(
+    "First-run setup for a creator Project: pick a learning mode, scaffold artifacts, create the local mind-map, optionally git-init."
+  ).option(
+    "--mode <ambient|explicit>",
+    "Skip the interactive prompt and set learning mode directly."
+  ).option("--no-git", "Skip `git init` (and skip writing .gitignore).").option(
+    "--no-scaffold",
+    "Skip writing DESIGN.md / SCRIPT.md / STORYBOARD.md templates."
+  ).option(
+    "--force",
+    "Force-overwrite existing artifact files when scaffolding (delegates to `atelier artifacts scaffold --force`)."
+  ).option("--json", "Emit a machine-readable JSON report instead of human-formatted output.").option(
+    "--no-workspace-relative",
+    "When inside a workspace, resolve <project-dir> relative to cwd instead of the workspace root. Useful for power-user paths that escape the workspace."
+  ).action(async (projectDir, opts) => {
+    try {
+      let resolvedProjectDir = projectDir;
+      let inheritedMode;
+      let workspaceCtx = null;
+      const cwd = process.cwd();
+      const workspaceRelative = opts.workspaceRelative !== false;
+      const ws = findWorkspace(cwd);
+      if (ws) {
+        workspaceCtx = ws;
+        if (workspaceRelative && !projectDir.startsWith("/") && !projectDir.startsWith(".")) {
+          resolvedProjectDir = (0, import_node_path22.join)(ws.workspaceDir, projectDir);
+        }
+        if (opts.mode === void 0) {
+          inheritedMode = ws.manifest.default_mode;
+        }
+      }
+      const result = await runInit({
+        projectDir: resolvedProjectDir,
+        mode: opts.mode ?? inheritedMode,
+        modeInheritedFromWorkspace: opts.mode === void 0 && inheritedMode !== void 0,
+        git: opts.git !== false,
+        scaffold: opts.scaffold !== false,
+        force: opts.force === true,
+        json: opts.json === true
+      });
+      if (workspaceCtx) {
+        try {
+          const projects = listProjects(workspaceCtx.workspaceDir);
+          writeWorkspace(workspaceCtx.workspaceDir, {
+            ...workspaceCtx.manifest,
+            version: "1.0",
+            created: workspaceCtx.manifest.created ?? (/* @__PURE__ */ new Date()).toISOString(),
+            projects
+          });
+        } catch {
+        }
+      }
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        for (const line of formatHumanReport(result)) {
+          console.log(line);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (opts.json) {
+        console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+      } else {
+        console.error(`atelier init: ${msg}`);
+      }
+      process.exit(1);
+    }
+  });
+}
+var MIND_MAP_README = `# Your Mind-Map
+
+This directory holds the creator's local asset library \u2014 clips, memes,
+graphics, audio \u2014 that the agent team queries when binding typed slots
+in recipes and storyboards (TD-2026-05-26-229).
+
+Organize however you want; the \`atelier_mind_map_query\` tool walks
+recursively and matches by file extension against slot \`kind\` values
+(image, video, audio, font, etc.).
+
+Nothing in this directory leaves your machine (TD-2026-05-26-271).
+`;
+var DEFAULT_GITIGNORE = `node_modules/
+*.log
+.atelier/cache/
+`;
+async function runInit(opts) {
+  const absDir = (0, import_node_path22.resolve)(opts.projectDir);
+  const notes = [];
+  let mode;
+  if (opts.mode !== void 0) {
+    const normalized = opts.mode.toLowerCase();
+    if (normalized !== "ambient" && normalized !== "explicit") {
+      throw new Error(
+        `invalid --mode "${opts.mode}" \u2014 expected one of ${LEARNING_MODES.join(", ")}`
+      );
+    }
+    mode = normalized;
+  }
+  if ((0, import_node_fs22.existsSync)(absDir)) {
+    const st = (0, import_node_fs22.statSync)(absDir);
+    if (!st.isDirectory()) {
+      throw new Error(`project path is not a directory: ${absDir}`);
+    }
+    if ((0, import_node_fs22.readdirSync)(absDir).length > 0) {
+      notes.push(`project dir exists and is non-empty; completing init in place`);
+    }
+  } else {
+    (0, import_node_fs22.mkdirSync)(absDir, { recursive: true });
+  }
+  if (mode === void 0) {
+    if (opts.promptForMode) {
+      mode = await opts.promptForMode();
+    } else if (opts.json) {
+      throw new Error(
+        `--mode is required with --json (scripted use must pre-declare; pass --mode ambient or --mode explicit)`
+      );
+    } else {
+      mode = await promptForLearningMode();
+    }
+  }
+  const learningModeFile = writeLearningMode(absDir, mode);
+  if (opts.modeInheritedFromWorkspace) {
+    notes.push(`learning mode inherited from workspace (${mode})`);
+  }
+  const mindMapDir = (0, import_node_path22.join)(absDir, ".atelier", "mind-map");
+  if (!(0, import_node_fs22.existsSync)(mindMapDir)) {
+    (0, import_node_fs22.mkdirSync)(mindMapDir, { recursive: true });
+  }
+  const readmePath = (0, import_node_path22.join)(mindMapDir, "README.md");
+  if (!(0, import_node_fs22.existsSync)(readmePath)) {
+    (0, import_node_fs22.writeFileSync)(readmePath, MIND_MAP_README, "utf-8");
+  }
+  if (opts.writeManifest !== false) {
+    const projectAtelierPath = (0, import_node_path22.join)(absDir, "project.atelier");
+    if (!(0, import_node_fs22.existsSync)(projectAtelierPath)) {
+      const minimalDoc = {
+        version: "1.0",
+        // Default to a vertical short-form canvas (TikTok/Reels/Shorts) at
+        // 30fps; Iris/Lux rewrite canvas dimensions when DESIGN.md specifies
+        // a different aspect ratio.
+        name: (0, import_node_path22.basename)(absDir),
+        canvas: { width: 1080, height: 1920, fps: 30 },
+        layers: [],
+        states: {}
+      };
+      (0, import_node_fs22.writeFileSync)(
+        projectAtelierPath,
+        JSON.stringify(minimalDoc, null, 2) + "\n",
+        "utf-8"
+      );
+    }
+  }
+  const scaffolded = [];
+  const scaffoldSkipped = [];
+  if (opts.scaffold) {
+    try {
+      const sr = scaffoldArtifacts(absDir, {
+        slots: [...ARTIFACT_SLOTS],
+        force: opts.force
+      });
+      scaffolded.push(...sr.created);
+      scaffoldSkipped.push(...sr.skipped);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.startsWith("refusing to overwrite")) {
+        notes.push(
+          `artifacts already present; skipped scaffold (use --force to replace)`
+        );
+      } else {
+        throw err;
+      }
+    }
+  }
+  let gitInitialized = false;
+  let alreadyInRepo = false;
+  if (opts.git) {
+    if (isInsideGitRepo(absDir)) {
+      alreadyInRepo = true;
+      notes.push(`already inside a git repo; skipped \`git init\``);
+    } else {
+      try {
+        (0, import_node_child_process4.execFileSync)("git", ["init"], { cwd: absDir, stdio: "ignore" });
+        gitInitialized = true;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        notes.push(`\`git init\` failed (${msg}); continuing without git`);
+      }
+      const gitignorePath = (0, import_node_path22.join)(absDir, ".gitignore");
+      if (!(0, import_node_fs22.existsSync)(gitignorePath)) {
+        (0, import_node_fs22.writeFileSync)(gitignorePath, DEFAULT_GITIGNORE, "utf-8");
+      }
+    }
+  }
+  return {
+    ok: true,
+    projectDir: absDir,
+    mode,
+    learningModeFile,
+    scaffolded,
+    scaffoldSkipped,
+    mindMapDir,
+    gitInitialized,
+    alreadyInRepo,
+    notes
+  };
+}
+function isInsideGitRepo(dir) {
+  try {
+    (0, import_node_child_process4.execFileSync)("git", ["-C", dir, "rev-parse", "--show-toplevel"], {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function promptForLearningMode() {
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  try {
+    process.stdout.write(
+      `How should your agent team learn?
+
+  1) Ambient \u2014 the team captures corrections silently and surfaces patterns when confident.
+  2) Explicit \u2014 nothing locks in without your "yes"; high-control, more friction.
+
+`
+    );
+    for (let attempt = 0; attempt < 3; attempt++) {
+      const answer = (await question(rl, `Choose [1/2]: `)).trim().toLowerCase();
+      const parsed = parseModeAnswer(answer);
+      if (parsed) return parsed;
+      process.stdout.write(`Please enter 1, 2, ambient, or explicit.
+`);
+    }
+    throw new Error(
+      `couldn't determine learning mode after 3 attempts (hint: re-run with --mode ambient or --mode explicit for scripted use)`
+    );
+  } finally {
+    rl.close();
+  }
+}
+function parseModeAnswer(answer) {
+  const a = answer.trim().toLowerCase();
+  if (a === "1" || a === "ambient") return "ambient";
+  if (a === "2" || a === "explicit") return "explicit";
+  return void 0;
+}
+function question(rl, prompt) {
+  return new Promise((resolvePromise) => {
+    rl.question(prompt, (answer) => resolvePromise(answer));
+  });
+}
+function formatHumanReport(r) {
+  const lines = [];
+  lines.push(`Project: ${r.projectDir}`);
+  lines.push(`  Learning mode: ${r.mode}`);
+  lines.push(`  Wrote ${r.learningModeFile}`);
+  lines.push(`  Mind-map: ${r.mindMapDir}`);
+  if (r.scaffolded.length > 0) {
+    lines.push(`  Scaffolded artifacts:`);
+    for (const f of r.scaffolded) lines.push(`    - ${f}`);
+  }
+  if (r.scaffoldSkipped.length > 0) {
+    lines.push(`  Skipped (already exists):`);
+    for (const f of r.scaffoldSkipped) lines.push(`    - ${f}`);
+  }
+  if (r.gitInitialized) {
+    lines.push(`  Initialized git repo`);
+  } else if (r.alreadyInRepo) {
+    lines.push(`  Git: already inside a repo (skipped)`);
+  }
+  for (const note of r.notes) {
+    lines.push(`  Note: ${note}`);
+  }
+  lines.push("");
+  lines.push(`Result: PASS`);
+  return lines;
+}
+
+// src/lib/compose-video-project.ts
+var import_node_fs24 = require("fs");
+var import_node_path24 = require("path");
+
+// src/lib/transcribe-orchestrator.ts
+var import_node_fs23 = require("fs");
+var import_node_path23 = require("path");
+async function transcribeMediaFile(projectDir, mediaBasename, options = {}) {
+  const absProject = (0, import_node_path23.resolve)(projectDir);
+  const stem = stripExt((0, import_node_path23.basename)(mediaBasename));
+  if (!stem) {
+    throw new Error(
+      `transcribeMediaFile: invalid mediaBasename "${mediaBasename}" \u2014 derived stem is empty`
+    );
+  }
+  const { transcribeFn, ...transcribeOpts } = options;
+  const fn = transcribeFn ?? transcribeProject;
+  const rootTranscript = (0, import_node_path23.join)(absProject, "transcript.json");
+  const priorRoot = (0, import_node_fs23.existsSync)(rootTranscript) ? (0, import_node_fs23.readFileSync)(rootTranscript) : null;
+  const result = await fn(absProject, transcribeOpts);
+  if (transcribeOpts.dryRun) {
+    return {
+      ...result,
+      mirroredTranscriptPath: (0, import_node_path23.join)(absProject, "transcripts", `${stem}.json`),
+      mediaStem: stem
+    };
+  }
+  const transcriptsDir = (0, import_node_path23.join)(absProject, "transcripts");
+  if (!(0, import_node_fs23.existsSync)(transcriptsDir)) {
+    (0, import_node_fs23.mkdirSync)(transcriptsDir, { recursive: true });
+  }
+  const mirroredTranscriptPath = (0, import_node_path23.join)(transcriptsDir, `${stem}.json`);
+  if ((0, import_node_fs23.existsSync)(rootTranscript)) {
+    (0, import_node_fs23.copyFileSync)(rootTranscript, mirroredTranscriptPath);
+  }
+  if (priorRoot !== null) {
+    (0, import_node_fs23.writeFileSync)(rootTranscript, priorRoot);
+  } else {
+    try {
+      (0, import_node_fs23.rmSync)(rootTranscript);
+    } catch {
+    }
+  }
+  return {
+    ...result,
+    mirroredTranscriptPath,
+    mediaStem: stem
+  };
+}
+function stripExt(name) {
+  const ext = (0, import_node_path23.extname)(name);
+  if (!ext) return name;
+  return name.slice(0, -ext.length);
+}
+
+// src/lib/timeline-ops.ts
+var VIDEO_TRACK_ID = "track-video-1";
+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 };
+}
+function stripStaleCaptionArtifacts(doc, clipLayerId) {
+  const droppedIds = /* @__PURE__ */ new Set();
+  const keptLayers = doc.layers.filter((layer) => {
+    if (!(layer.tags ?? []).includes("caption")) return true;
+    if (!layer.parentId) {
+      droppedIds.add(layer.id);
+      return false;
+    }
+    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 };
+}
+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 };
+}
+
+// src/lib/compose-video-project.ts
+function readAtelierDoc(absPath) {
+  const raw = (0, import_node_fs24.readFileSync)(absPath, "utf-8");
+  const parsed = parseAtelier(raw);
+  if (parsed.success) return parsed.data;
+  return JSON.parse(raw);
+}
+var POSSIBLE_SOURCE_EXTS = [".mp4", ".mov", ".webm", ".mkv", ".avi"];
+function slugifyBasename(name) {
+  const base = (0, import_node_path24.basename)(name);
+  const stem = stripExt2(base);
+  const lower = stem.toLowerCase();
+  const replaced = lower.replace(/[^a-z0-9]+/g, "-");
+  return replaced.replace(/^-+|-+$/g, "");
+}
+function stripExt2(name) {
+  const ext = (0, import_node_path24.extname)(name);
+  return ext ? name.slice(0, -ext.length) : name;
+}
+async function composeVideoProject(opts) {
+  const projectDir = (0, import_node_path24.resolve)(opts.projectDir);
+  const compositionPath = (0, import_node_path24.join)(projectDir, opts.docPath);
+  (0, import_node_fs24.mkdirSync)((0, import_node_path24.dirname)(compositionPath), { recursive: true });
+  if (!(0, import_node_fs24.existsSync)(compositionPath)) {
+    const seedDoc = {
+      version: "1.0",
+      name: (0, import_node_path24.basename)(projectDir),
+      kind: "video",
+      canvas: { width: 1080, height: 1920, fps: 30 },
+      layers: [],
+      states: { default: { duration: 0, deltas: [] } }
+    };
+    (0, import_node_fs24.writeFileSync)(compositionPath, JSON.stringify(seedDoc, null, 2), "utf-8");
+  }
+  const sourceBasename = canonicalSourceName(opts.sourceFile, projectDir);
+  const clipSlug = slugifyBasename(sourceBasename);
+  if (!clipSlug) {
+    throw new Error(
+      `composeVideoProject: cannot derive a slug from source "${opts.sourceFile}"`
+    );
+  }
+  const clipLayerId = `clip-${clipSlug}`;
+  let transcribeResult;
+  let mirroredTranscriptPath;
+  const shouldTranscribe = opts.transcribe !== false;
+  if (shouldTranscribe) {
+    const noCaptionsOverride = { noCaptions: true };
+    if (opts.mediaBasename) {
+      const result = await transcribeMediaFile(projectDir, opts.mediaBasename, {
+        ...opts.transcribeOptions ?? {},
+        ...noCaptionsOverride,
+        ...opts.transcribeFn !== void 0 ? { transcribeFn: opts.transcribeFn } : {}
+      });
+      transcribeResult = result;
+      mirroredTranscriptPath = result.mirroredTranscriptPath;
+    } else {
+      const fn = opts.transcribeFn ?? transcribeProject;
+      transcribeResult = await fn(projectDir, {
+        ...opts.transcribeOptions ?? {},
+        ...noCaptionsOverride
+      });
+    }
+  }
+  let doc = readAtelierDoc(compositionPath);
+  doc = stripStaleCaptionArtifacts(doc, clipLayerId);
+  const probeFn = opts.probeDurationFn ?? probeDuration;
+  let clipDurationSeconds;
+  try {
+    clipDurationSeconds = await probeFn(opts.sourceFile);
+  } catch {
+    clipDurationSeconds = lastTranscriptWordEnd(transcribeResult?.transcript) ?? 0;
+  }
+  const fps = doc.canvas.fps;
+  const clipDurationFrames = Math.max(1, Math.round(clipDurationSeconds * fps));
+  const { doc: docWithClip, addedLayer } = ensureClipLayer(doc, {
+    clipLayerId,
+    trackId: VIDEO_TRACK_ID,
+    sourceName: sourceBasename,
+    clipDurationSeconds,
+    clipDurationFrames,
+    kind: "video"
+  });
+  doc = docWithClip;
+  if (transcribeResult?.transcript) {
+    doc = rebuildClipCaptions(
+      doc,
+      clipLayerId,
+      transcribeResult.transcript,
+      doc.canvas,
+      opts.captionOptions ?? {}
+    );
+  }
+  doc = recomputeTimeline(doc);
+  const stateNames = Object.keys(doc.states);
+  const targetStateName = stateNames.includes("default") ? "default" : stateNames[0] ?? "default";
+  const totalFrames = doc.timeline?.totalFrames ?? 0;
+  const states = { ...doc.states };
+  const existing = states[targetStateName];
+  const updatedState = existing ? { ...existing, duration: Math.max(existing.duration, totalFrames) } : { duration: totalFrames, deltas: [] };
+  states[targetStateName] = updatedState;
+  doc = { ...doc, states };
+  (0, import_node_fs24.writeFileSync)(compositionPath, JSON.stringify(doc, null, 2), "utf-8");
+  return {
+    doc,
+    addedVideoLayer: addedLayer,
+    clipSlug,
+    clipLayerId,
+    targetStateName,
+    targetDurationSeconds: clipDurationSeconds,
+    ...transcribeResult !== void 0 ? { transcribe: transcribeResult } : {},
+    ...mirroredTranscriptPath !== void 0 ? { mirroredTranscriptPath } : {}
+  };
+}
+function canonicalSourceName(sourceFile, projectDir) {
+  const abs = (0, import_node_path24.resolve)(sourceFile);
+  const projectAbs = (0, import_node_path24.resolve)(projectDir);
+  const ext = (0, import_node_path24.extname)(abs);
+  if (POSSIBLE_SOURCE_EXTS.includes(ext.toLowerCase())) {
+    const flat = `${projectAbs}/source${ext}`;
+    if ((0, import_node_path24.resolve)(flat) === abs) return `source${ext}`;
+  }
+  if (abs.startsWith(`${projectAbs}/`)) {
+    return abs.slice(projectAbs.length + 1);
+  }
+  return (0, import_node_path24.basename)(abs);
+}
+function lastTranscriptWordEnd(transcript) {
+  if (!transcript) return void 0;
+  let max = 0;
+  for (const seg of transcript.segments) {
+    for (const w of seg.words) {
+      if (w.end > max) max = w.end;
+    }
+  }
+  return max > 0 ? max : void 0;
+}
+
+// src/lib/compose-image-project.ts
+var import_node_fs25 = require("fs");
+var import_node_path25 = require("path");
+async function composeImageProject(opts) {
+  const projectDir = (0, import_node_path25.resolve)(opts.projectDir);
+  const sourceAbs = (0, import_node_path25.resolve)(opts.sourceFile);
+  const mediaBasename = opts.mediaBasename ?? (0, import_node_path25.basename)(sourceAbs);
+  const mediaDir = `${projectDir}/media`;
+  if (!(0, import_node_fs25.existsSync)(mediaDir)) (0, import_node_fs25.mkdirSync)(mediaDir, { recursive: true });
+  const mediaDest = `${mediaDir}/${mediaBasename}`;
+  if (!(0, import_node_fs25.existsSync)(mediaDest)) {
+    (0, import_node_fs25.copyFileSync)(sourceAbs, mediaDest);
+  }
+  const compositionPath = (0, import_node_path25.join)(projectDir, opts.docPath);
+  (0, import_node_fs25.mkdirSync)((0, import_node_path25.dirname)(compositionPath), { recursive: true });
+  let doc;
+  if ((0, import_node_fs25.existsSync)(compositionPath)) {
+    doc = readAtelierDoc(compositionPath);
+  } else {
+    doc = {
+      version: "1.0",
+      name: (0, import_node_path25.basename)(projectDir),
+      kind: "image",
+      canvas: { width: 1080, height: 1920, fps: 30 },
+      layers: [],
+      states: { default: { duration: 1, deltas: [] } }
+    };
+  }
+  const slug = slugifyBasename(mediaBasename);
+  if (!slug) {
+    throw new Error(
+      `composeImageProject: cannot derive a slug from "${mediaBasename}"`
+    );
+  }
+  const layerId = `img-${slug}`;
+  const expectedSrc = `media/${mediaBasename}`;
+  const existingImageLayer = doc.layers.find((l) => {
+    if (!l.id.startsWith("img-")) return false;
+    const v = l.visual;
+    return v?.type === "image";
+  });
+  if (existingImageLayer) {
+    const existingSrc = existingImageLayer.visual.src ?? "";
+    const existingBasename = (0, import_node_path25.basename)(existingSrc);
+    if (existingBasename !== mediaBasename) {
+      throw new Error(
+        "image project already has an image; rename or delete the existing image before adding another"
+      );
+    }
+    return {
+      doc,
+      addedImageLayer: false,
+      layerId: existingImageLayer.id,
+      assetId: existingImageLayer.id
+    };
+  }
+  const newLayer = {
+    id: layerId,
+    tags: ["image"],
+    description: mediaBasename,
+    visual: {
+      type: "image",
+      assetId: layerId,
+      src: expectedSrc
+    },
+    frame: { x: 0, y: 0 },
+    bounds: { width: doc.canvas.width, height: doc.canvas.height }
+  };
+  const assets = { ...doc.assets ?? {} };
+  assets[layerId] = {
+    type: "image",
+    src: expectedSrc,
+    description: mediaBasename
+  };
+  doc = {
+    ...doc,
+    layers: [...doc.layers, newLayer],
+    assets
+  };
+  (0, import_node_fs25.writeFileSync)(compositionPath, JSON.stringify(doc, null, 2), "utf-8");
+  return {
+    doc,
+    addedImageLayer: true,
+    layerId,
+    assetId: layerId
+  };
+}
+
+// src/lib/compose-carousel-project.ts
+var import_node_fs27 = require("fs");
+var import_node_path27 = require("path");
+
+// src/lib/ref-cycle.ts
+var import_node_fs26 = require("fs");
+var import_node_path26 = require("path");
+var MAX_HOPS = 64;
+function detectCarouselCycle(rootPath, candidatePath, workspaceRoot) {
+  const rootAbs = (0, import_node_path26.resolve)(rootPath);
+  const candAbs = (0, import_node_path26.resolve)(candidatePath);
+  const workspaceAbs = (0, import_node_path26.resolve)(workspaceRoot);
+  if (rootAbs === candAbs) {
+    return { cycle: true, path: [rootAbs, candAbs] };
+  }
+  const frontier = [{ abs: candAbs, chain: [rootAbs, candAbs] }];
+  const visited = /* @__PURE__ */ new Set();
+  let hops = 0;
+  while (frontier.length > 0) {
+    if (hops++ >= MAX_HOPS) {
+      return { cycle: false };
+    }
+    const current = frontier.shift();
+    if (visited.has(current.abs)) continue;
+    visited.add(current.abs);
+    if (!(0, import_node_fs26.existsSync)(current.abs)) {
+      console.warn(`detectCarouselCycle: missing referenced file ${current.abs}`);
+      continue;
+    }
+    let doc;
+    try {
+      const raw = (0, import_node_fs26.readFileSync)(current.abs, "utf-8");
+      const parsed = parseAtelier(raw);
+      if (parsed.success) {
+        doc = parsed.data;
+      } else {
+        doc = JSON.parse(raw);
+      }
+    } catch (err) {
+      console.warn(
+        `detectCarouselCycle: failed to parse ${current.abs}: ${err.message}`
+      );
+      continue;
+    }
+    const refs = [];
+    if (doc.slides) {
+      for (const slide of doc.slides) {
+        if (typeof slide.src === "string" && slide.src) refs.push(slide.src);
+      }
+    }
+    if (doc.layers) {
+      for (const layer of doc.layers) {
+        const v = layer.visual;
+        if (v && v.type === "ref") {
+          const r = v;
+          if (typeof r.src === "string" && r.src) refs.push(r.src);
+        }
+      }
+    }
+    for (const ref of refs) {
+      const resolved = resolveRef(ref, current.abs, workspaceAbs);
+      if (resolved === void 0) {
+        console.warn(
+          `detectCarouselCycle: missing referenced file "${ref}" (from ${current.abs})`
+        );
+        continue;
+      }
+      if (resolved === rootAbs || resolved === candAbs) {
+        return { cycle: true, path: [...current.chain, resolved] };
+      }
+      if (!visited.has(resolved)) {
+        frontier.push({ abs: resolved, chain: [...current.chain, resolved] });
+      }
+    }
+  }
+  return { cycle: false };
+}
+function resolveRef(ref, currentDocPath, workspaceRoot) {
+  if ((0, import_node_path26.isAbsolute)(ref)) {
+    return (0, import_node_fs26.existsSync)(ref) ? (0, import_node_path26.resolve)(ref) : void 0;
+  }
+  const docRelative = (0, import_node_path26.resolve)((0, import_node_path26.dirname)(currentDocPath), ref);
+  if ((0, import_node_fs26.existsSync)(docRelative)) return docRelative;
+  const workspaceRelative = (0, import_node_path26.resolve)(workspaceRoot, ref);
+  if ((0, import_node_fs26.existsSync)(workspaceRelative)) return workspaceRelative;
+  return void 0;
+}
+
+// src/lib/compose-carousel-project.ts
+async function composeCarouselProject(opts) {
+  const projectDir = (0, import_node_path27.resolve)(opts.projectDir);
+  const slidePath = (0, import_node_path27.resolve)(opts.slidePath);
+  const workspaceRoot = (0, import_node_path27.resolve)(opts.workspaceRoot ?? (0, import_node_path27.dirname)(projectDir));
+  const compositionPath = (0, import_node_path27.join)(projectDir, opts.docPath);
+  (0, import_node_fs27.mkdirSync)((0, import_node_path27.dirname)(compositionPath), { recursive: true });
+  let doc;
+  if ((0, import_node_fs27.existsSync)(compositionPath)) {
+    doc = readAtelierDoc(compositionPath);
+  } else {
+    doc = {
+      version: "1.0",
+      name: (0, import_node_path27.basename)(projectDir),
+      kind: "carousel",
+      canvas: { width: 1080, height: 1920, fps: 30 },
+      layers: [],
+      states: { default: { duration: 1, deltas: [] } },
+      slides: []
+    };
+  }
+  if (doc.kind !== void 0 && doc.kind !== "carousel") {
+    throw new Error("project is not a carousel; cannot add slides");
+  }
+  const cycleResult = detectCarouselCycle(
+    compositionPath,
+    slidePath,
+    workspaceRoot
+  );
+  if (cycleResult.cycle) {
+    const chain = cycleResult.path ?? [];
+    throw new Error(`carousel cycle detected: ${chain.join(" \u2192 ")}`);
+  }
+  const computedSrc = (0, import_node_path27.relative)(workspaceRoot, slidePath);
+  const slides = doc.slides ? [...doc.slides] : [];
+  const existingIndex = slides.findIndex((s) => s.src === computedSrc);
+  if (existingIndex >= 0) {
+    if (!(0, import_node_fs27.existsSync)(compositionPath)) {
+      doc = { ...doc, slides };
+      (0, import_node_fs27.writeFileSync)(compositionPath, JSON.stringify(doc, null, 2), "utf-8");
+    }
+    return {
+      doc: { ...doc, slides },
+      addedSlide: false,
+      slideIndex: existingIndex
+    };
+  }
+  const slideRef = { src: computedSrc };
+  if (opts.duration !== void 0) slideRef.duration = opts.duration;
+  if (opts.transition !== void 0) slideRef.transition = opts.transition;
+  if (opts.label !== void 0) slideRef.label = opts.label;
+  let insertIndex;
+  if (opts.insertAt !== void 0) {
+    insertIndex = Math.max(0, Math.min(opts.insertAt, slides.length));
+    slides.splice(insertIndex, 0, slideRef);
+  } else {
+    insertIndex = slides.length;
+    slides.push(slideRef);
+  }
+  doc = { ...doc, slides };
+  (0, import_node_fs27.writeFileSync)(compositionPath, JSON.stringify(doc, null, 2), "utf-8");
+  return {
+    doc,
+    addedSlide: true,
+    slideIndex: insertIndex
+  };
+}
+
+// src/lib/ingest-dispatch.ts
+var import_node_fs28 = require("fs");
+var import_node_path28 = require("path");
+var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".mkv", ".avi"]);
+var IMAGE_EXTS2 = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".webp", ".gif"]);
+var AUDIO_EXTS = /* @__PURE__ */ new Set([".mp3", ".wav", ".m4a", ".aac", ".flac", ".ogg"]);
+function classifyMediaFile(filename) {
+  const ext = (0, import_node_path28.extname)(filename).toLowerCase();
+  if (!ext) return "unsupported";
+  if (VIDEO_EXTS.has(ext)) return "video";
+  if (IMAGE_EXTS2.has(ext)) return "image";
+  if (AUDIO_EXTS.has(ext)) return "audio";
+  return "unsupported";
+}
+function routeIngest(filename) {
+  const kind = classifyMediaFile(filename);
+  if (kind === "unsupported") {
+    return { kind, target: "reject", error: "file type not supported" };
+  }
+  return { kind, target: "add-to-bin" };
+}
+function routeIngestWithTarget(filename, targetDocPath, targetDocKind) {
+  const kind = classifyMediaFile(filename);
+  if (kind === "unsupported") {
+    return { kind, target: "reject", error: "file type not supported" };
+  }
+  if (targetDocKind === void 0) {
+    return {
+      kind,
+      target: "reject",
+      error: "target doc kind unresolved"
+    };
+  }
+  if (kind === "video") {
+    if (targetDocKind === "video") {
+      return { kind, target: "compose-video", docPath: targetDocPath };
+    }
+    return {
+      kind,
+      target: "reject",
+      error: targetDocKind === "image" ? "cannot add video clip to an image doc" : "cannot add video clip to a carousel doc"
+    };
+  }
+  if (kind === "audio") {
+    if (targetDocKind === "video") {
+      return { kind, target: "add-audio-clip", docPath: targetDocPath };
+    }
+    return {
+      kind,
+      target: "reject",
+      error: targetDocKind === "image" ? "cannot add audio to an image doc" : "cannot add audio to a carousel doc"
+    };
+  }
+  return {
+    kind,
+    target: "reject",
+    error: "image drag-drop into an existing doc not supported in v1"
+  };
+}
+
+// src/lib/doc-management.ts
+var import_node_fs29 = require("fs");
+var import_node_path29 = require("path");
+
+// 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;
+}
+
+// src/lib/doc-management.ts
+var MAX_COLLISION_ATTEMPTS = 999;
+async function createDoc(opts) {
+  if (!isValidDocName(opts.name)) {
+    throw new Error("invalid doc name");
+  }
+  const slug = slugifyBasename(opts.name);
+  if (!slug) {
+    throw new Error("invalid doc name");
+  }
+  const projectDir = (0, import_node_path29.resolve)(opts.projectDir);
+  const subdir = opts.asCarouselSlide ? "slides" : "";
+  const subdirAbs = subdir ? (0, import_node_path29.join)(projectDir, subdir) : projectDir;
+  let chosenName;
+  let chosenAbs;
+  for (let attempt = 0; attempt <= MAX_COLLISION_ATTEMPTS; attempt++) {
+    const candidateStem = attempt === 0 ? slug : `${slug}-${attempt}`;
+    const candidateName = `${candidateStem}.atelier`;
+    const candidateAbs = (0, import_node_path29.join)(subdirAbs, candidateName);
+    if (!(0, import_node_fs29.existsSync)(candidateAbs)) {
+      chosenName = candidateName;
+      chosenAbs = candidateAbs;
+      break;
+    }
+  }
+  if (!chosenName || !chosenAbs) {
+    throw new Error("collision suffix exhausted (999 attempts)");
+  }
+  const docPath = subdir ? `${subdir}/${chosenName}` : chosenName;
+  const docName = chosenName.slice(0, -".atelier".length);
+  const doc = scaffoldDoc(docName, opts.kind);
+  if (subdir) {
+    (0, import_node_fs29.mkdirSync)(subdirAbs, { recursive: true });
+  }
+  (0, import_node_fs29.writeFileSync)(chosenAbs, JSON.stringify(doc, null, 2), "utf-8");
+  let appendedSlideIndex;
+  if (opts.asCarouselSlide && opts.carouselDocPath) {
+    const carouselAbs = (0, import_node_path29.isAbsolute)(opts.carouselDocPath) ? opts.carouselDocPath : (0, import_node_path29.join)(projectDir, opts.carouselDocPath);
+    const carouselProjectDir = (0, import_node_path29.dirname)(carouselAbs);
+    const carouselDocRel = (0, import_node_path29.relative)(carouselProjectDir, carouselAbs);
+    try {
+      const composeOpts = {
+        projectDir: carouselProjectDir,
+        docPath: carouselDocRel,
+        slidePath: chosenAbs
+      };
+      if (opts.insertAt !== void 0) composeOpts.insertAt = opts.insertAt;
+      const composeResult = await composeCarouselProject(composeOpts);
+      appendedSlideIndex = composeResult.slideIndex;
+    } catch (err) {
+      try {
+        (0, import_node_fs29.unlinkSync)(chosenAbs);
+      } catch {
+      }
+      throw err;
+    }
+  }
+  return {
+    doc,
+    docPath,
+    ...appendedSlideIndex !== void 0 ? { appendedSlideIndex } : {}
+  };
+}
+function scaffoldDoc(name, kind) {
+  const base = {
+    version: "1.0",
+    name,
+    kind,
+    canvas: { width: 1080, height: 1920, fps: 30 },
+    layers: [],
+    states: { default: { duration: 1, deltas: [] } }
+  };
+  if (kind === "carousel") {
+    base.slides = [];
+  }
+  return base;
+}
+async function duplicateDoc(opts) {
+  const projectDir = (0, import_node_path29.resolve)(opts.projectDir);
+  const sourceAbs = (0, import_node_path29.join)(projectDir, opts.sourceDocPath);
+  if (!(0, import_node_fs29.existsSync)(sourceAbs)) {
+    throw new Error("source doc not found");
+  }
+  const doc = readAtelierDoc(sourceAbs);
+  const sourceDir = (0, import_node_path29.dirname)(sourceAbs);
+  const sourceBase = (0, import_node_path29.basename)(sourceAbs);
+  const sourceExt = (0, import_node_path29.extname)(sourceBase);
+  const sourceStem = sourceExt ? sourceBase.slice(0, -sourceExt.length) : sourceBase;
+  let chosenAbs;
+  let chosenStem;
+  for (let attempt = 1; attempt <= MAX_COLLISION_ATTEMPTS; attempt++) {
+    const candidateStem = attempt === 1 ? `${sourceStem}-copy` : `${sourceStem}-copy-${attempt}`;
+    const candidateAbs = (0, import_node_path29.join)(sourceDir, `${candidateStem}${sourceExt}`);
+    if (!(0, import_node_fs29.existsSync)(candidateAbs)) {
+      chosenAbs = candidateAbs;
+      chosenStem = candidateStem;
+      break;
+    }
+  }
+  if (!chosenAbs || !chosenStem) {
+    throw new Error("collision suffix exhausted (999 attempts)");
+  }
+  const newDocPath = sourceRelDir(opts.sourceDocPath) ? `${sourceRelDir(opts.sourceDocPath)}/${chosenStem}${sourceExt}` : `${chosenStem}${sourceExt}`;
+  (0, import_node_fs29.writeFileSync)(chosenAbs, JSON.stringify(doc, null, 2), "utf-8");
+  let appendedSlideIndex;
+  if (opts.appendSlideRef) {
+    const sourceDirRel = sourceRelDir(opts.sourceDocPath);
+    if (sourceDirRel !== "slides") {
+      try {
+        (0, import_node_fs29.unlinkSync)(chosenAbs);
+      } catch {
+      }
+      throw new Error("appendSlideRef requires a slide source");
+    }
+    const manifestPath = (0, import_node_path29.join)(projectDir, "project.atelier");
+    let sourceIndex = -1;
+    if ((0, import_node_fs29.existsSync)(manifestPath)) {
+      try {
+        const manifest = readAtelierDoc(manifestPath);
+        if (manifest.kind === "carousel" && Array.isArray(manifest.slides)) {
+          const workspaceRoot = (0, import_node_path29.dirname)(projectDir);
+          for (let i = 0; i < manifest.slides.length; i++) {
+            const ref = manifest.slides[i];
+            const resolved = resolveSlideRef(ref.src, projectDir, workspaceRoot);
+            if (resolved === sourceAbs) {
+              sourceIndex = i;
+              break;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    try {
+      const composeOpts = {
+        projectDir,
+        docPath: "project.atelier",
+        slidePath: chosenAbs
+      };
+      if (sourceIndex >= 0) composeOpts.insertAt = sourceIndex + 1;
+      const composeResult = await composeCarouselProject(composeOpts);
+      appendedSlideIndex = composeResult.slideIndex;
+    } catch (err) {
+      try {
+        (0, import_node_fs29.unlinkSync)(chosenAbs);
+      } catch {
+      }
+      throw err;
+    }
+  }
+  return {
+    sourceDocPath: opts.sourceDocPath,
+    newDocPath,
+    ...appendedSlideIndex !== void 0 ? { appendedSlideIndex } : {}
+  };
+}
+function sourceRelDir(relPath) {
+  const dir = (0, import_node_path29.dirname)(relPath);
+  return dir === "." ? "" : dir;
+}
+function deleteDoc(opts) {
+  const workspaceAbs = (0, import_node_path29.resolve)(opts.workspaceDir);
+  const projectDir = (0, import_node_path29.join)(workspaceAbs, opts.projectName);
+  const docAbs = (0, import_node_path29.join)(projectDir, opts.docPath);
+  if (!(0, import_node_fs29.existsSync)(docAbs)) {
+    throw new Error("doc not found");
+  }
+  const slideRefsRemoved = [];
+  const refLayersDangling = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs29.readdirSync)(workspaceAbs);
+  } catch {
+    entries = [];
+  }
+  for (const entry of entries) {
+    if (entry.startsWith(".")) continue;
+    const otherProjectDir = (0, import_node_path29.join)(workspaceAbs, entry);
+    let st;
+    try {
+      st = (0, import_node_fs29.statSync)(otherProjectDir);
+    } catch {
+      continue;
+    }
+    if (!st.isDirectory()) continue;
+    const projectDocs = enumerateProjectAtelierDocs(otherProjectDir);
+    for (const { absPath, relPath } of projectDocs) {
+      if (absPath === docAbs) continue;
+      let otherDoc;
+      try {
+        otherDoc = readAtelierDoc(absPath);
+      } catch {
+        continue;
+      }
+      let docMutated = false;
+      if (otherDoc.kind === "carousel" && Array.isArray(otherDoc.slides)) {
+        const slides = otherDoc.slides;
+        const matchIndices = [];
+        for (let i = 0; i < slides.length; i++) {
+          const ref = slides[i];
+          const resolved = resolveSlideRef(ref.src, otherProjectDir, workspaceAbs);
+          if (resolved === docAbs) {
+            matchIndices.push(i);
+            slideRefsRemoved.push({ project: entry, slideIndex: i });
+          }
+        }
+        if (matchIndices.length > 0) {
+          const matchSet = new Set(matchIndices);
+          const kept = slides.filter((_, i) => !matchSet.has(i));
+          otherDoc = { ...otherDoc, slides: kept };
+          docMutated = true;
+        }
+      }
+      if (Array.isArray(otherDoc.layers)) {
+        for (const layer of otherDoc.layers) {
+          const v = layer.visual;
+          if (v && v.type === "ref") {
+            const refVisual = v;
+            if (typeof refVisual.src === "string" && refVisual.src.length > 0) {
+              const resolved = resolveSlideRef(refVisual.src, otherProjectDir, workspaceAbs);
+              if (resolved === docAbs) {
+                refLayersDangling.push({
+                  project: entry,
+                  docPath: relPath,
+                  layerId: layer.id
+                });
+              }
+            }
+          }
+        }
+      }
+      if (docMutated) {
+        (0, import_node_fs29.writeFileSync)(absPath, JSON.stringify(otherDoc, null, 2), "utf-8");
+      }
+    }
+  }
+  (0, import_node_fs29.unlinkSync)(docAbs);
+  return {
+    docPath: opts.docPath,
+    slideRefsRemoved,
+    refLayersDangling
+  };
+}
+function resolveSlideRef(src, ownerProjectDir, workspaceRoot) {
+  if ((0, import_node_path29.isAbsolute)(src)) {
+    return (0, import_node_fs29.existsSync)(src) ? (0, import_node_path29.resolve)(src) : void 0;
+  }
+  const projectRelative = (0, import_node_path29.resolve)(ownerProjectDir, src);
+  if ((0, import_node_fs29.existsSync)(projectRelative)) return projectRelative;
+  const workspaceRelative = (0, import_node_path29.resolve)(workspaceRoot, src);
+  if ((0, import_node_fs29.existsSync)(workspaceRelative)) return workspaceRelative;
+  return void 0;
+}
+function listDocs(projectDir) {
+  const projectAbs = (0, import_node_path29.resolve)(projectDir);
+  const found = enumerateProjectAtelierDocs(projectAbs);
+  const out = found.map(({ absPath, relPath }) => {
+    let kind;
+    try {
+      const doc = readAtelierDoc(absPath);
+      kind = doc.kind;
+    } catch {
+      kind = void 0;
+    }
+    const entry = { path: relPath };
+    if (kind !== void 0) entry.kind = kind;
+    return entry;
+  }).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return out;
+}
+function enumerateProjectAtelierDocs(projectAbs) {
+  const out = [];
+  for (const sub of ["", "slides"]) {
+    const dirAbs = sub ? (0, import_node_path29.join)(projectAbs, sub) : projectAbs;
+    let entries;
+    try {
+      entries = (0, import_node_fs29.readdirSync)(dirAbs);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (!name.endsWith(".atelier")) continue;
+      if (name === ".atelier") continue;
+      const abs = (0, import_node_path29.join)(dirAbs, name);
+      try {
+        const st = (0, import_node_fs29.statSync)(abs);
+        if (!st.isFile()) continue;
+      } catch {
+        continue;
+      }
+      const relPath = sub ? `${sub}/${name}` : name;
+      out.push({ absPath: abs, relPath });
+    }
+  }
+  return out;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ARTIFACT_FILENAMES,
   CanvasUnavailableError,
+  LEARNING_MODES,
+  LEARNING_MODE_VERSION,
   RECIPE_VERSION,
   VIDEO_CUTLIST_VERSION,
   VIDEO_PROJECT_VERSION,
@@ -5841,6 +8786,7 @@ Done.`);
   applyRecipeToTrimOptions,
   applySplit,
   applyTextEdit,
+  artifactsCommand,
   assetsCommand,
   buildCaptionLayers,
   buildFfmpegArgs,
@@ -5848,8 +8794,15 @@ Done.`);
   carouselCommand,
   carouselFileName,
   checkFfmpeg,
+  classifyMediaFile,
   composeCarouselFrameDoc,
+  composeCarouselProject,
+  composeImageProject,
+  composeVideoProject,
+  createDoc,
   createVideoProject,
+  deleteDoc,
+  duplicateDoc,
   effectiveSpan,
   expandInputs,
   exportImageCommand,
@@ -5862,26 +8815,38 @@ Done.`);
   getVariables,
   groupIntoPhrases,
   infoCommand,
+  initCommand,
+  isInsideGitRepo,
+  isValidDocName,
+  learningModePath,
+  listDocs,
+  loadArtifactsFromProject,
   loadCanvasModule,
   loadRecipe,
   loadVideoProject,
   mergeTranscriptWithExisting,
+  parseModeAnswer,
   parseWhisperCppJson,
   probeWhisper,
   readComposition,
   readCutList,
+  readLearningMode,
   readTranscript,
   recipeCommand,
   recipeToYaml,
   renderCommand,
   renderDocument,
   renderDocumentToPng,
+  renderLearningModeYaml,
   renderRecipeWithDefaults,
   resolveExportDimensions,
   resolveRecipePath,
   resolveStill,
   rewriteCaptionLayers,
   rewriteCutLayers,
+  routeIngest,
+  routeIngestWithTarget,
+  runInit,
   runWhisperCpp,
   scaffoldRecipeYaml,
   stillCommand,
@@ -5895,6 +8860,7 @@ Done.`);
   variablesCommand,
   writeComposition,
   writeCutList,
+  writeLearningMode,
   writeTranscript
 });
 //# sourceMappingURL=index.cjs.map