@a-company/atelier 0.28.2 → 0.29.0

package/dist/cli.cjs

@@ -420,7 +420,18 @@ function resolveFrame(doc, stateName, frame, overrideDeltas) {
         }
       }
     }
-    return { id: layer.id, layer, computedProperties };
+    const resolvedLayer = { id: layer.id, layer, computedProperties };
+    if (layer.visual.type === "video") {
+      const video = layer.visual;
+      const fps = doc.canvas.fps;
+      const startFrame = video.startFrame ?? 0;
+      const sourceOffset = video.sourceOffset ?? 0;
+      const playbackRate = video.playbackRate ?? 1;
+      const relativeFrame = Math.max(0, frame - startFrame);
+      const sourceTime = relativeFrame / fps * playbackRate + sourceOffset;
+      resolvedLayer.videoSourceTime = video.sourceEnd !== void 0 ? Math.min(sourceTime, video.sourceEnd) : sourceTime;
+    }
+    return resolvedLayer;
   });
   return { frame, stateName, layers: resolvedLayers };
 }
@@ -1027,6 +1038,14 @@ function renderImage(ctx, eff, imageCache) {
   }
   ctx.drawImage(img, 0, 0, eff.width, eff.height);
 }
+function renderVideo(ctx, eff, sourceTime, provider) {
+  const visual = eff.visual;
+  const src = visual.src;
+  if (!src) return;
+  const frame = provider(src, sourceTime, eff.width, eff.height);
+  if (!frame) return;
+  ctx.drawImage(frame, 0, 0, eff.width, eff.height);
+}
 function renderRef(ctx, eff, opts, _parentDoc) {
   const visual = eff.visual;
   const resolver = opts?.documentResolver;
@@ -1124,6 +1143,7 @@ function renderPlaceholder(ctx, eff, label) {
 function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
   let imageCache;
   let documentResolver;
+  let videoFrameProvider;
   let maxRefDepth = 4;
   if (optsOrCache && typeof optsOrCache.get === "function") {
     imageCache = optsOrCache;
@@ -1131,6 +1151,7 @@ function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
     const opts = optsOrCache;
     imageCache = opts.imageCache;
     documentResolver = opts.documentResolver;
+    videoFrameProvider = opts.videoFrameProvider;
     maxRefDepth = opts.maxRefDepth ?? 4;
   }
   const { width, height } = doc.canvas;
@@ -1138,10 +1159,14 @@ function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
   ctx.fillRect(0, 0, width, height);
   const effMap = /* @__PURE__ */ new Map();
   const effList = [];
+  const videoSourceTimeMap = /* @__PURE__ */ new Map();
   for (const resolvedLayer of resolvedFrame.layers) {
     const eff = buildEffectiveLayer(resolvedLayer, width, height);
     effMap.set(resolvedLayer.layer.id, eff);
     effList.push(eff);
+    if (resolvedLayer.videoSourceTime !== void 0) {
+      videoSourceTimeMap.set(resolvedLayer.layer.id, resolvedLayer.videoSourceTime);
+    }
   }
   for (const eff of effList) {
     const { layer } = eff;
@@ -1153,6 +1178,12 @@ function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
         iv.src = doc.assets[iv.assetId].src;
       }
     }
+    if (layer.visual.type === "video") {
+      const vv = eff.visual;
+      if (!vv.src && vv.assetId && doc.assets?.[vv.assetId]) {
+        vv.src = doc.assets[vv.assetId].src;
+      }
+    }
     ctx.save();
     applyAncestorTransforms(ctx, layer.id, effMap, doc);
     ctx.globalAlpha = eff.opacity;
@@ -1200,6 +1231,11 @@ function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
       case "image":
         if (imageCache) renderImage(renderCtx, eff, imageCache);
         break;
+      case "video":
+        if (videoFrameProvider) {
+          renderVideo(renderCtx, eff, videoSourceTimeMap.get(layer.id) ?? 0, videoFrameProvider);
+        }
+        break;
       case "group":
         break;
       case "ref":
@@ -1225,6 +1261,9 @@ function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
         case "image":
           if (imageCache) renderImage(offCtx, eff, imageCache);
           break;
+        case "video":
+          if (videoFrameProvider) renderVideo(offCtx, eff, videoSourceTimeMap.get(layer.id) ?? 0, videoFrameProvider);
+          break;
         case "ref":
           renderRef(offCtx, eff, refOpts, doc);
           break;
@@ -1240,6 +1279,9 @@ function renderFrame(ctx, resolvedFrame, doc, optsOrCache) {
         case "image":
           if (imageCache) renderImage(ctx, eff, imageCache);
           break;
+        case "video":
+          if (videoFrameProvider) renderVideo(ctx, eff, videoSourceTimeMap.get(layer.id) ?? 0, videoFrameProvider);
+          break;
         case "ref":
           renderRef(ctx, eff, refOpts, doc);
           break;
@@ -1642,6 +1684,18 @@ var ImageVisualSchema = import_zod7.z.object({
   spritesheet: SpritesheetConfigSchema.optional(),
   frameIndex: import_zod7.z.number().int().min(0).optional()
 });
+var VideoVisualSchema = import_zod7.z.object({
+  type: import_zod7.z.literal("video"),
+  assetId: import_zod7.z.string().min(1, "assetId is required"),
+  src: import_zod7.z.string().optional(),
+  startFrame: import_zod7.z.number().int().min(0).optional(),
+  sourceOffset: import_zod7.z.number().min(0).optional(),
+  sourceEnd: import_zod7.z.number().positive().optional(),
+  playbackRate: import_zod7.z.number().positive().optional(),
+  volume: import_zod7.z.number().min(0).max(1).optional(),
+  muted: import_zod7.z.boolean().optional(),
+  objectFit: import_zod7.z.enum(["contain", "cover", "fill"]).optional()
+});
 var GroupVisualSchema = import_zod7.z.object({
   type: import_zod7.z.literal("group")
 });
@@ -1655,6 +1709,7 @@ var VisualSchema = import_zod7.z.discriminatedUnion("type", [
   ShapeVisualSchema,
   TextVisualSchema,
   ImageVisualSchema,
+  VideoVisualSchema,
   GroupVisualSchema,
   RefVisualSchema
 ]);
@@ -1774,7 +1829,7 @@ var VariableSchema = import_zod12.z.object({
   default: import_zod12.z.unknown().optional(),
   description: import_zod12.z.string().optional()
 });
-var AssetTypeSchema = import_zod13.z.enum(["image", "svg", "font", "animation", "audio"]);
+var AssetTypeSchema = import_zod13.z.enum(["image", "svg", "font", "animation", "audio", "video"]);
 var AssetSchema = import_zod13.z.object({
   type: AssetTypeSchema,
   src: import_zod13.z.string().min(1, "Asset src is required"),
@@ -1785,6 +1840,12 @@ var AssetSchema = import_zod13.z.object({
     frameCount: import_zod13.z.number().int().positive().optional(),
     frameWidth: import_zod13.z.number().positive(),
     frameHeight: import_zod13.z.number().positive()
+  }).optional(),
+  videoMeta: import_zod13.z.object({
+    duration: import_zod13.z.number().positive("videoMeta.duration must be positive"),
+    fps: import_zod13.z.number().positive("videoMeta.fps must be positive"),
+    width: import_zod13.z.number().int().positive(),
+    height: import_zod13.z.number().int().positive()
   }).optional()
 });
 var CanvasSchema = import_zod14.z.object({
@@ -1818,6 +1879,35 @@ function validateDocument(input) {
   }
   return { success: false, errors: formatErrors(result.error) };
 }
+function validateVideoLayer(visual, videoMetaDuration) {
+  const errors = [];
+  if (!visual.assetId) {
+    errors.push({ path: "assetId", message: "assetId is required" });
+  }
+  const sourceOffset = visual.sourceOffset ?? 0;
+  if (visual.sourceEnd !== void 0) {
+    if (visual.sourceEnd <= sourceOffset) {
+      errors.push({
+        path: "sourceEnd",
+        message: `sourceEnd (${visual.sourceEnd}) must be greater than sourceOffset (${sourceOffset})`
+      });
+    }
+    if (videoMetaDuration !== void 0 && visual.sourceEnd > videoMetaDuration) {
+      errors.push({
+        path: "sourceEnd",
+        message: `sourceEnd (${visual.sourceEnd}) exceeds asset duration (${videoMetaDuration})`
+      });
+    }
+  }
+  if (videoMetaDuration !== void 0 && sourceOffset >= videoMetaDuration) {
+    errors.push({
+      path: "sourceOffset",
+      message: `sourceOffset (${sourceOffset}) is at or beyond asset duration (${videoMetaDuration})`
+    });
+  }
+  if (errors.length > 0) return { success: false, errors };
+  return { success: true, data: visual };
+}
 function parseAtelier(yamlString) {
   let parsed;
   try {
@@ -1877,9 +1967,105 @@ function validateCommand(program2) {
   });
 }
 
-// src/commands/info.ts
+// src/commands/lint.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
+init_dist2();
+function lintFile(filePath) {
+  const absPath = (0, import_node_path2.resolve)(filePath);
+  let content;
+  try {
+    content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+  } catch {
+    return {
+      file: absPath,
+      valid: false,
+      gates: [
+        {
+          gate: "^valid-document",
+          pass: false,
+          errors: [`Cannot read file: ${absPath}`]
+        }
+      ]
+    };
+  }
+  const gates = [];
+  const parseResult = parseAtelier(content);
+  if (!parseResult.success) {
+    gates.push({
+      gate: "^valid-document",
+      pass: false,
+      errors: parseResult.errors.map((e) => `${e.path}: ${e.message}`)
+    });
+    return { file: absPath, valid: false, gates };
+  }
+  gates.push({ gate: "^valid-document", pass: true, errors: [] });
+  const doc = parseResult.data;
+  const deltaErrors = [];
+  for (const [stateName, state] of Object.entries(doc.states)) {
+    const overlaps = validateAllDeltas(state.deltas);
+    for (const overlap of overlaps) {
+      deltaErrors.push(`State "${stateName}": ${overlap.message}`);
+    }
+  }
+  gates.push({
+    gate: "^valid-delta",
+    pass: deltaErrors.length === 0,
+    errors: deltaErrors
+  });
+  const videoErrors = [];
+  for (const layer of doc.layers) {
+    if (layer.visual.type !== "video") continue;
+    const visual = layer.visual;
+    const duration = doc.assets?.[visual.assetId]?.videoMeta?.duration;
+    const result = validateVideoLayer(visual, duration);
+    if (!result.success) {
+      for (const err of result.errors) {
+        videoErrors.push(`Layer "${layer.id}" (${err.path}): ${err.message}`);
+      }
+    }
+  }
+  gates.push({
+    gate: "^valid-video-layer",
+    pass: videoErrors.length === 0,
+    errors: videoErrors
+  });
+  const valid = gates.every((g) => g.pass);
+  return { file: absPath, valid, gates };
+}
+function formatResult(result) {
+  const lines = [];
+  const status = result.valid ? "PASS" : "FAIL";
+  lines.push(`${status}  ${result.file}`);
+  for (const gate of result.gates) {
+    const gateStatus = gate.pass ? "  \u2713" : "  \u2717";
+    lines.push(`${gateStatus} ${gate.gate}`);
+    for (const err of gate.errors) {
+      lines.push(`       ${err}`);
+    }
+  }
+  return lines.join("\n");
+}
+function lintCommand(program2) {
+  program2.command("lint <files...>").description(
+    "Lint .atelier files against all gates (^valid-document, ^valid-delta, ^valid-video-layer)"
+  ).option("--json", "Output results as JSON array").action((files, opts) => {
+    const results = files.map(lintFile);
+    if (opts.json) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      for (const result of results) {
+        console.log(formatResult(result));
+      }
+    }
+    const allValid = results.every((r) => r.valid);
+    if (!allValid) process.exit(1);
+  });
+}
+
+// src/commands/info.ts
+var import_node_fs3 = require("fs");
+var import_node_path3 = require("path");
 function getInfo(doc) {
   return {
     name: doc.name,
@@ -1936,10 +2122,10 @@ function formatInfo(info) {
   return lines.join("\n");
 }
 function readAndParse(file) {
-  const absPath = (0, import_node_path2.resolve)(file);
+  const absPath = (0, import_node_path3.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs2.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -1963,8 +2149,8 @@ function infoCommand(program2) {
 }
 
 // src/commands/still.ts
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
 init_dist2();
 function resolveStill(doc, stateName, frame) {
   const stateNames = Object.keys(doc.states);
@@ -1981,10 +2167,10 @@ function resolveStill(doc, stateName, frame) {
   return resolveFrame(doc, resolvedStateName, resolvedFrame);
 }
 function readAndParse2(file) {
-  const absPath = (0, import_node_path3.resolve)(file);
+  const absPath = (0, import_node_path4.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs3.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs4.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -2035,7 +2221,7 @@ function stillCommand(program2) {
         if (options.format === "json") {
           const json = JSON.stringify(resolved, null, 2);
           if (options.output) {
-            (0, import_node_fs3.writeFileSync)((0, import_node_path3.resolve)(options.output), json, "utf-8");
+            (0, import_node_fs4.writeFileSync)((0, import_node_path4.resolve)(options.output), json, "utf-8");
           } else {
             console.log(json);
           }
@@ -2055,7 +2241,7 @@ function stillCommand(program2) {
           renderFrame2(ctx, resolved, doc);
           const buffer = cvs.toBuffer("image/png");
           if (options.output) {
-            (0, import_node_fs3.writeFileSync)((0, import_node_path3.resolve)(options.output), buffer);
+            (0, import_node_fs4.writeFileSync)((0, import_node_path4.resolve)(options.output), buffer);
           } else {
             process.stdout.write(buffer);
           }
@@ -2071,18 +2257,18 @@ function stillCommand(program2) {
 }
 
 // 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");
 init_dist2();
 init_dist3();
 async function checkFfmpeg() {
-  return new Promise((resolve10) => {
+  return new Promise((resolve11) => {
     const proc = (0, import_node_child_process.spawn)("ffmpeg", ["-version"], { stdio: "pipe" });
-    proc.on("error", () => resolve10(false));
-    proc.on("close", (code) => resolve10(code === 0));
+    proc.on("error", () => resolve11(false));
+    proc.on("close", (code) => resolve11(code === 0));
   });
 }
 function buildFfmpegArgs(width, height, fps, format, output) {
@@ -2162,7 +2348,7 @@ async function preloadImages(doc, loadImage) {
   for (const src of preloaded.keys()) {
     imageCache.load(src);
   }
-  await new Promise((resolve10) => process.nextTick(resolve10));
+  await new Promise((resolve11) => process.nextTick(resolve11));
   return imageCache;
 }
 async function renderDocument(doc, opts) {
@@ -2226,7 +2412,7 @@ async function renderDocument(doc, opts) {
       const canWrite = ffmpeg.stdin.write(raw);
       if (!canWrite) {
         await new Promise(
-          (resolve10) => ffmpeg.stdin.once("drain", resolve10)
+          (resolve11) => ffmpeg.stdin.once("drain", resolve11)
         );
       }
       frameIndex++;
@@ -2239,8 +2425,8 @@ async function renderDocument(doc, opts) {
     }
   }
   ffmpeg.stdin.end();
-  const exitCode = await new Promise((resolve10) => {
-    ffmpeg.on("close", resolve10);
+  const exitCode = await new Promise((resolve11) => {
+    ffmpeg.on("close", resolve11);
   });
   if (exitCode !== 0) {
     throw new Error(
@@ -2259,10 +2445,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);
@@ -2279,7 +2465,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";
 }
@@ -2313,12 +2499,12 @@ function renderCommand(program2) {
       } 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,
           onProgress: ({ frame, totalFrames, state, percent }) => {
@@ -2344,8 +2530,8 @@ function renderCommand(program2) {
 }
 
 // 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();
@@ -2810,10 +2996,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);
@@ -2855,7 +3041,7 @@ function exportSvgCommand(program2) {
           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);
         }
@@ -2868,8 +3054,8 @@ function exportSvgCommand(program2) {
 }
 
 // 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) {
@@ -3438,10 +3624,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);
@@ -3469,7 +3655,7 @@ function exportLottieCommand(program2) {
         }
         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);
         }
@@ -3482,8 +3668,8 @@ function exportLottieCommand(program2) {
 }
 
 // src/commands/assets.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");
 function getAssets(doc) {
   const assets = doc.assets ?? {};
   return Object.entries(assets).map(([assetId, asset]) => {
@@ -3515,10 +3701,10 @@ function formatAssets(assets) {
   return lines.join("\n");
 }
 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);
@@ -3542,8 +3728,8 @@ function assetsCommand(program2) {
 }
 
 // src/commands/variables.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");
 init_dist2();
 function getVariables(doc) {
   const variables = doc.variables ?? {};
@@ -3579,10 +3765,10 @@ function formatVariables(info) {
   return lines.join("\n");
 }
 function readAndParse7(file) {
-  const absPath = (0, import_node_path8.resolve)(file);
+  const absPath = (0, import_node_path9.resolve)(file);
   let content;
   try {
-    content = (0, import_node_fs8.readFileSync)(absPath, "utf-8");
+    content = (0, import_node_fs9.readFileSync)(absPath, "utf-8");
   } catch {
     console.error(`Cannot read file: ${absPath}`);
     return process.exit(1);
@@ -3606,8 +3792,8 @@ function variablesCommand(program2) {
 }
 
 // src/commands/studio.ts
-var import_node_path9 = require("path");
-var import_node_fs9 = require("fs");
+var import_node_path10 = require("path");
+var import_node_fs10 = require("fs");
 var import_node_os = require("os");
 var import_node_crypto = require("crypto");
 var import_node_child_process2 = require("child_process");
@@ -3616,30 +3802,30 @@ function findAtelierFiles(dir, base = dir) {
   const results = [];
   let entries;
   try {
-    entries = (0, import_node_fs9.readdirSync)(dir);
+    entries = (0, import_node_fs10.readdirSync)(dir);
   } catch {
     return results;
   }
   for (const entry of entries) {
     if (entry === "node_modules" || entry === "dist" || entry === ".git") continue;
-    const full = (0, import_node_path9.join)(dir, entry);
+    const full = (0, import_node_path10.join)(dir, entry);
     let stat;
     try {
-      stat = (0, import_node_fs9.statSync)(full);
+      stat = (0, import_node_fs10.statSync)(full);
     } catch {
       continue;
     }
     if (stat.isDirectory()) {
       results.push(...findAtelierFiles(full, base));
     } else if (entry.endsWith(".atelier")) {
-      results.push((0, import_node_path9.relative)(base, full));
+      results.push((0, import_node_path10.relative)(base, full));
     }
   }
   return results.sort();
 }
 function isSafePath(filePath) {
   if (!filePath || filePath.includes("..") || filePath.startsWith("/")) return false;
-  const resolved = (0, import_node_path9.resolve)(process.cwd(), filePath);
+  const resolved = (0, import_node_path10.resolve)(process.cwd(), filePath);
   return resolved.startsWith(process.cwd());
 }
 function getInlineHTML() {
@@ -4093,17 +4279,17 @@ function studioCommand(program2) {
         process.exit(1);
       }
       const cwd = process.cwd();
-      const cliPackageDir = (0, import_node_path9.resolve)((0, import_node_path9.dirname)(new URL(import_meta.url).pathname), "..");
+      const cliPackageDir = (0, import_node_path10.resolve)((0, import_node_path10.dirname)(new URL(import_meta.url).pathname), "..");
       const tmpId = (0, import_node_crypto.randomBytes)(4).toString("hex");
-      const tmpDirRaw = (0, import_node_path9.join)((0, import_node_os.tmpdir)(), `atelier-studio-${tmpId}`);
-      (0, import_node_fs9.mkdirSync)(tmpDirRaw, { recursive: true });
-      const tmpDir = (0, import_node_fs9.realpathSync)(tmpDirRaw);
-      (0, import_node_fs9.writeFileSync)((0, import_node_path9.join)(tmpDir, "index.html"), getInlineHTML());
-      (0, import_node_fs9.writeFileSync)((0, import_node_path9.join)(tmpDir, "main.ts"), getInlineApp(file ?? null));
-      const cliNodeModules = (0, import_node_path9.join)(cliPackageDir, "node_modules");
-      if ((0, import_node_fs9.existsSync)(cliNodeModules)) {
+      const tmpDirRaw = (0, import_node_path10.join)((0, import_node_os.tmpdir)(), `atelier-studio-${tmpId}`);
+      (0, import_node_fs10.mkdirSync)(tmpDirRaw, { recursive: true });
+      const tmpDir = (0, import_node_fs10.realpathSync)(tmpDirRaw);
+      (0, import_node_fs10.writeFileSync)((0, import_node_path10.join)(tmpDir, "index.html"), getInlineHTML());
+      (0, import_node_fs10.writeFileSync)((0, import_node_path10.join)(tmpDir, "main.ts"), getInlineApp(file ?? null));
+      const cliNodeModules = (0, import_node_path10.join)(cliPackageDir, "node_modules");
+      if ((0, import_node_fs10.existsSync)(cliNodeModules)) {
         try {
-          (0, import_node_fs9.symlinkSync)(cliNodeModules, (0, import_node_path9.join)(tmpDir, "node_modules"), "dir");
+          (0, import_node_fs10.symlinkSync)(cliNodeModules, (0, import_node_path10.join)(tmpDir, "node_modules"), "dir");
         } catch {
         }
       }
@@ -4154,10 +4340,10 @@ function studioCommand(program2) {
                     res.end("Invalid path");
                     return;
                   }
-                  const absPath = (0, import_node_path9.resolve)(cwd, filePath);
+                  const absPath = (0, import_node_path10.resolve)(cwd, filePath);
                   if (req.method === "GET") {
                     try {
-                      const content = (0, import_node_fs9.readFileSync)(absPath, "utf-8");
+                      const content = (0, import_node_fs10.readFileSync)(absPath, "utf-8");
                       res.setHeader("Content-Type", "text/plain");
                       res.end(content);
                     } catch {
@@ -4173,7 +4359,7 @@ function studioCommand(program2) {
                     });
                     req.on("end", () => {
                       try {
-                        (0, import_node_fs9.writeFileSync)(absPath, body, "utf-8");
+                        (0, import_node_fs10.writeFileSync)(absPath, body, "utf-8");
                         res.end("OK");
                       } catch {
                         res.statusCode = 500;
@@ -4190,15 +4376,15 @@ function studioCommand(program2) {
                     res.end("Invalid path");
                     return;
                   }
-                  const absPath = (0, import_node_path9.resolve)(cwd, filePath);
+                  const absPath = (0, import_node_path10.resolve)(cwd, filePath);
                   const chunks = [];
                   req.on("data", (chunk) => {
                     chunks.push(chunk);
                   });
                   req.on("end", () => {
                     try {
-                      (0, import_node_fs9.mkdirSync)((0, import_node_path9.dirname)(absPath), { recursive: true });
-                      (0, import_node_fs9.writeFileSync)(absPath, Buffer.concat(chunks));
+                      (0, import_node_fs10.mkdirSync)((0, import_node_path10.dirname)(absPath), { recursive: true });
+                      (0, import_node_fs10.writeFileSync)(absPath, Buffer.concat(chunks));
                       res.end("OK");
                     } catch {
                       res.statusCode = 500;
@@ -4237,7 +4423,7 @@ function studioCommand(program2) {
         console.log("\nShutting down...");
         server.close();
         try {
-          (0, import_node_fs9.rmSync)(tmpDir, { recursive: true, force: true });
+          (0, import_node_fs10.rmSync)(tmpDir, { recursive: true, force: true });
         } catch {
         }
         process.exit(0);
@@ -4253,6 +4439,7 @@ var import_meta2 = {};
 var program = new import_commander.Command();
 program.name("atelier").description("Atelier animation CLI").version((0, import_node_module.createRequire)(import_meta2.url)("../package.json").version);
 validateCommand(program);
+lintCommand(program);
 infoCommand(program);
 stillCommand(program);
 renderCommand(program);