@osmo.inc/cli-linux-arm64 0.1.19 → 0.1.20

package/dist/studio.js

@@ -215,10 +215,170 @@ var init_labels = __esm({
   }
 });
 
-// src/comments.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile2, rename as rename2, rm as rm3 } from "node:fs/promises";
+// src/local-attachment-picker.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { realpath, stat } from "node:fs/promises";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import path7 from "node:path";
+async function registerLocalAttachment(filename2) {
+  const sourcePath = await realpath(filename2), info = await stat(sourcePath);
+  if (!info.isFile()) throw new Error("Choose a file, not a folder.");
+  const localRef = randomUUID2();
+  const file = {
+    name: path7.basename(sourcePath),
+    type: types[path7.extname(sourcePath).toLowerCase()] ?? "application/octet-stream",
+    size: info.size,
+    sourcePath
+  };
+  selections.set(localRef, file);
+  return { localRef, name: file.name, type: file.type, size: file.size };
+}
+function selectedLocalAttachment(token) {
+  const file = selections.get(token);
+  if (!file)
+    throw new Error("Select this file again; its local selection expired.");
+  return file;
+}
+async function pickLocalAttachments() {
+  if (picking) throw new Error("The file picker is already open.");
+  if (process.platform !== "darwin")
+    throw new Error("Local reference selection currently requires macOS.");
+  picking = true;
+  try {
+    const script = 'var app=Application.currentApplication(); app.includeStandardAdditions=true; try {var files=app.chooseFile({withPrompt:"Attach original files (no copies)",multipleSelectionsAllowed:true}); JSON.stringify(files.map(function(f){return f.toString()}));} catch(e) {if(e.errorNumber===-128) JSON.stringify([]); else throw e;}';
+    const { stdout } = await exec(
+      "/usr/bin/osascript",
+      ["-l", "JavaScript", "-e", script],
+      { maxBuffer: 8 * 1024 * 1024 }
+    );
+    const paths = JSON.parse(stdout);
+    return Promise.all(
+      paths.map((file) => registerLocalAttachment(file))
+    );
+  } finally {
+    picking = false;
+  }
+}
+var exec, selections, types, picking;
+var init_local_attachment_picker = __esm({
+  "src/local-attachment-picker.ts"() {
+    "use strict";
+    exec = promisify(execFile);
+    selections = /* @__PURE__ */ new Map();
+    types = {
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".webp": "image/webp",
+      ".gif": "image/gif",
+      ".avif": "image/avif",
+      ".mp4": "video/mp4",
+      ".mov": "video/quicktime",
+      ".pdf": "application/pdf",
+      ".txt": "text/plain"
+    };
+    picking = false;
+  }
+});
+
+// src/comment-attachments.ts
+import { mkdir as mkdir3, writeFile as writeFile2, rm as rm3, realpath as realpath2, readFile as readFile3 } from "node:fs/promises";
+import path8 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+function validateUploads(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error("Invalid attachments.");
+  if (value.some((f) => f?.localRef !== void 0 && (typeof f.localRef !== "string" || !f.localRef)))
+    throw new Error("Invalid local attachment reference.");
+  if (value.filter((f) => typeof f?.localRef !== "string").length > 5)
+    throw new Error("Choose up to 5 cloud files.");
+  let total = 0;
+  return value.map((f) => {
+    if (f && typeof f.localRef === "string")
+      return { ...selectedLocalAttachment(f.localRef) };
+    if (!f || typeof f.name !== "string" || !f.name.trim() || f.name.length > 255 || typeof f.type !== "string" || f.type.length > 255 || typeof f.data !== "string" || f.data.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(f.data))
+      throw new Error("Invalid attachment.");
+    if (f.data.length > 4 * Math.ceil(15 * 1024 * 1024 / 3))
+      throw new Error("Each file must be 15 MB or smaller.");
+    const bytes = Buffer.from(f.data, "base64");
+    if (bytes.length > 15 * 1024 * 1024)
+      throw new Error("Each file must be 15 MB or smaller.");
+    total += bytes.length;
+    if (total > 50 * 1024 * 1024)
+      throw new Error("Files must total 50 MB or less.");
+    return { name: f.name, type: f.type, bytes };
+  });
+}
+async function storeAttachments(root, id, uploads, saved) {
+  const project = await realpath2(root);
+  for (const file of uploads) {
+    if (file.sourcePath) {
+      const { stat: stat4 } = await import("node:fs/promises");
+      const info = await stat4(file.sourcePath);
+      if (!info.isFile())
+        throw new Error("The attached file is no longer available.");
+      saved.push({
+        name: file.name,
+        path: file.sourcePath,
+        type: file.type,
+        size: info.size,
+        local: true
+      });
+      continue;
+    }
+    const bytes = file.bytes;
+    const folder = path8.join(root, ".osmo", "attachments", id, randomUUID3());
+    await mkdir3(folder, { recursive: true });
+    const resolved = await realpath2(folder);
+    if (!resolved.startsWith(project + path8.sep))
+      throw new Error("Attachment folder is outside the project.");
+    const name = file.name.replace(/[\\/\x00-\x1f\x7f]/g, "_").replace(/^\.+$/, "file");
+    const relative = path8.relative(root, path8.join(folder, name));
+    saved.push({
+      name: file.name,
+      path: relative,
+      type: file.type,
+      size: bytes.length
+    });
+    await writeFile2(path8.join(folder, name), bytes, { flag: "wx" });
+  }
+}
+async function cleanupAttachments(root, files) {
+  for (const file of files.filter((file2) => !file2.local))
+    await rm3(path8.dirname(path8.join(root, file.path)), {
+      recursive: true,
+      force: true
+    });
+}
+async function attachmentPath(root, file) {
+  if (file.local) {
+    if (!path8.isAbsolute(file.path))
+      throw new Error("Invalid local attachment reference.");
+    try {
+      return await realpath2(file.path);
+    } catch {
+      throw new Error("Original file was moved or removed. Attach it again.");
+    }
+  }
+  const base = await realpath2(path8.join(root, ".osmo", "attachments"));
+  const resolved = await realpath2(path8.resolve(root, file.path));
+  if (!resolved.startsWith(base + path8.sep))
+    throw new Error("Invalid attachment path.");
+  return resolved;
+}
+var init_comment_attachments = __esm({
+  "src/comment-attachments.ts"() {
+    "use strict";
+    init_local_attachment_picker();
+  }
+});
+
+// src/comments.ts
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3, rename as rename2, rm as rm4 } from "node:fs/promises";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import path9 from "node:path";
 function validBounds(value) {
   return !!value && ["x", "y", "width", "height"].every((key) => Number.isFinite(value[key])) && value.width >= 0 && value.height >= 0;
 }
@@ -242,7 +402,7 @@ function validAgentResponse(value) {
 }
 async function readComments(root) {
   try {
-    const data = JSON.parse(await readFile3(filename(root), "utf8"));
+    const data = JSON.parse(await readFile4(filename(root), "utf8"));
     if (data.version !== 1 || !Array.isArray(data.comments))
       throw new Error("Unsupported comments file");
     const ids = /* @__PURE__ */ new Set();
@@ -270,13 +430,13 @@ function commentText(value) {
   return value.trim();
 }
 async function mutateComments(root, change) {
-  const folder = path7.join(root, ".osmo");
-  await mkdir3(folder, { recursive: true });
-  const lock = path7.join(folder, "comments.lock");
+  const folder = path9.join(root, ".osmo");
+  await mkdir4(folder, { recursive: true });
+  const lock = path9.join(folder, "comments.lock");
   const start = Date.now();
   while (true) {
     try {
-      await mkdir3(lock);
+      await mkdir4(lock);
       break;
     } catch (e) {
       if (e.code !== "EEXIST") throw e;
@@ -287,22 +447,23 @@ async function mutateComments(root, change) {
       await new Promise((resolve) => setTimeout(resolve, 25));
     }
   }
-  const temporary = path7.join(folder, `comments.${randomUUID2()}.tmp`);
+  const temporary = path9.join(folder, `comments.${randomUUID4()}.tmp`);
   try {
     const data = await readComments(root);
-    const result = change(data.comments);
-    await writeFile2(temporary, JSON.stringify(data, null, 2) + "\n", {
+    const result = await change(data.comments);
+    await writeFile3(temporary, JSON.stringify(data, null, 2) + "\n", {
       flag: "wx"
     });
     await rename2(temporary, filename(root));
     return result;
   } finally {
-    await rm3(temporary, { force: true });
-    await rm3(lock, { recursive: true, force: true });
+    await rm4(temporary, { force: true });
+    await rm4(lock, { recursive: true, force: true });
   }
 }
 async function addComment(root, input) {
-  const text = commentText(input.text);
+  const uploads = validateUploads(input.attachments);
+  const text = uploads.length && typeof input.text === "string" && !input.text.trim() ? "" : commentText(input.text);
   if (typeof input.scene !== "string" || !input.scene || input.scene.startsWith("/") || input.scene.split(/[\\/]/).includes(".."))
     throw new Error("Invalid comment scene");
   if (!Number.isFinite(input.time) || input.time < 0 || input.endTime !== void 0 && (!Number.isFinite(input.endTime) || input.endTime < input.time))
@@ -313,42 +474,60 @@ async function addComment(root, input) {
     throw new Error("Invalid comment target");
   if (input.author !== void 0 && !validAuthor(input.author))
     throw new Error("Invalid comment author");
-  return mutateComments(root, (comments) => {
-    const comment = {
-      id: `c_${randomUUID2().slice(0, 8)}`,
-      scene: input.scene,
-      time: input.time,
-      ...input.endTime === void 0 ? {} : { endTime: input.endTime },
-      ...input.target === void 0 ? {} : { target: input.target },
-      ...input.author === void 0 ? {} : { author: input.author },
-      text,
-      status: "open",
-      revision: input.revision,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      replies: []
-    };
-    comments.push(comment);
-    return comment;
-  });
+  const saved = [];
+  try {
+    return await mutateComments(root, async (comments) => {
+      const comment = {
+        id: `c_${randomUUID4().slice(0, 8)}`,
+        scene: input.scene,
+        time: input.time,
+        ...input.endTime === void 0 ? {} : { endTime: input.endTime },
+        ...input.target === void 0 ? {} : { target: input.target },
+        ...input.author === void 0 ? {} : { author: input.author },
+        text,
+        status: "open",
+        revision: input.revision,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        replies: []
+      };
+      await storeAttachments(root, comment.id, uploads, saved);
+      if (saved.length) comment.attachments = saved;
+      comments.push(comment);
+      return comment;
+    });
+  } catch (error) {
+    await cleanupAttachments(root, saved);
+    throw error;
+  }
 }
-async function updateComment(root, id, action, text) {
+async function updateComment(root, id, action, text, attachments) {
   if (!["reply", "resolve", "reopen"].includes(action))
     throw new Error("Unknown comment action");
-  if (action === "reply") text = commentText(text);
-  return mutateComments(root, (comments) => {
-    const comment = comments.find((c) => c.id === id);
-    if (!comment) throw new Error(`Comment not found: ${id}`);
-    if (action === "reply")
-      comment.replies.push({
-        id: randomUUID2(),
-        // commentText returned it above: this is a reply.
-        text,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    else comment.status = action === "resolve" ? "resolved" : "open";
-    comment.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return comment;
-  });
+  const uploads = validateUploads(attachments);
+  if (action === "reply")
+    text = uploads.length && text === "" ? "" : commentText(text);
+  const saved = [];
+  try {
+    return await mutateComments(root, async (comments) => {
+      const comment = comments.find((c) => c.id === id);
+      if (!comment) throw new Error(`Comment not found: ${id}`);
+      if (action === "reply") {
+        await storeAttachments(root, id, uploads, saved);
+        comment.replies.push({
+          ...saved.length ? { attachments: saved } : {},
+          id: randomUUID4(),
+          // commentText returned it above: this is a reply.
+          text,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } else comment.status = action === "resolve" ? "resolved" : "open";
+      comment.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      return comment;
+    });
+  } catch (error) {
+    await cleanupAttachments(root, saved);
+    throw error;
+  }
 }
 async function updateCommentRange(root, id, input) {
   if (!Number.isFinite(input.time) || input.time < 0 || !Number.isFinite(input.endTime) || input.endTime <= input.time)
@@ -397,13 +576,131 @@ var filename, AGENT_REACTION_MIN_MS, graphemes, isoTime;
 var init_comments = __esm({
   "src/comments.ts"() {
     "use strict";
-    filename = (root) => path7.join(root, ".osmo/comments.json");
+    init_comment_attachments();
+    filename = (root) => path9.join(root, ".osmo/comments.json");
     AGENT_REACTION_MIN_MS = 3e4;
     graphemes = new Intl.Segmenter("en", { granularity: "grapheme" });
     isoTime = (value) => typeof value === "string" && Number.isFinite(Date.parse(value));
   }
 });
 
+// src/attachment-thumbnail.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+import { stat as stat2 } from "node:fs/promises";
+async function attachmentThumbnail(filename2) {
+  const info = await stat2(filename2), key = `${filename2}:${info.mtimeMs}:${info.size}`;
+  const existing = cache.get(key);
+  if (existing) return existing;
+  const result = exec2(
+    "ffmpeg",
+    [
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-i",
+      filename2,
+      "-frames:v",
+      "1",
+      "-vf",
+      "scale=96:96:force_original_aspect_ratio=decrease",
+      "-f",
+      "image2pipe",
+      "-vcodec",
+      "mjpeg",
+      "pipe:1"
+    ],
+    { encoding: "buffer", maxBuffer: 1024 * 1024, timeout: 15e3 }
+  ).then(({ stdout }) => {
+    if (!stdout.length) throw new Error("No video preview");
+    return stdout;
+  }).catch((error) => {
+    cache.delete(key);
+    throw error;
+  });
+  if (cache.size >= 64) cache.delete(cache.keys().next().value);
+  cache.set(key, result);
+  return result;
+}
+var exec2, cache;
+var init_attachment_thumbnail = __esm({
+  "src/attachment-thumbnail.ts"() {
+    "use strict";
+    exec2 = promisify2(execFile2);
+    cache = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../scene/src/assets.ts
+function validAssetPath(kind, value) {
+  return Object.hasOwn(assetExtensions, kind) && typeof value === "string" && value.length > 0 && value.length <= 4096 && value === value.trim() && !/^[a-z][a-z0-9+.-]*:|^[/\\]|[\x00-\x1f?#\\]/i.test(value) && assetExtensions[kind].includes(value.split(".").at(-1).toLowerCase());
+}
+var assetExtensions;
+var init_assets = __esm({
+  "../scene/src/assets.ts"() {
+    "use strict";
+    assetExtensions = {
+      image: ["png", "jpg", "jpeg", "webp", "gif", "svg"],
+      video: ["mp4", "webm", "mov", "m4v"],
+      audio: ["wav", "mp3", "m4a", "aac", "ogg", "flac"],
+      font: ["ttf", "otf"],
+      model: ["glb"]
+    };
+  }
+});
+
+// src/asset-import.ts
+import fs2 from "node:fs/promises";
+import path13 from "node:path";
+import { randomUUID as randomUUID5 } from "node:crypto";
+async function importProjectAsset(root, stream, name, kind, limit = MAX_ASSET_BYTES) {
+  if (!Object.hasOwn(assetExtensions, kind))
+    throw new Error("Unknown asset kind");
+  if (!name || name.length > 255 || /[/\\\x00-\x1f]/.test(name))
+    throw new Error("Invalid asset filename");
+  const extension = path13.extname(name).slice(1).toLowerCase();
+  if (!assetExtensions[kind].includes(extension))
+    throw new Error(
+      `Expected a ${kind} file (${assetExtensions[kind].join(", ")})`
+    );
+  const folder = path13.join(root, "assets");
+  await fs2.mkdir(folder).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  const directory = sceneInProject(root, "assets").source;
+  const stem = path13.basename(name, path13.extname(name)).normalize("NFKC").replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "asset";
+  const filename2 = `${stem}-${randomUUID5()}.${extension}`;
+  const target = path13.join(directory, filename2);
+  const temp = path13.join(directory, `.${filename2}.upload`);
+  const file = await fs2.open(temp, "wx", 384);
+  let size = 0;
+  try {
+    for await (const chunk of stream) {
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      size += bytes.length;
+      if (size > limit)
+        throw new Error(`Asset exceeds ${Math.round(limit / 1024 / 1024)} MB`);
+      await file.writeFile(bytes);
+    }
+    if (!size) throw new Error("Asset file is empty");
+    await file.close();
+    await fs2.link(temp, target);
+    return path13.relative(await fs2.realpath(root), target).split(path13.sep).join("/");
+  } finally {
+    await file.close();
+    await fs2.rm(temp, { force: true });
+  }
+}
+var MAX_ASSET_BYTES;
+var init_asset_import = __esm({
+  "src/asset-import.ts"() {
+    "use strict";
+    init_assets();
+    init_runtime();
+    MAX_ASSET_BYTES = 256 * 1024 * 1024;
+  }
+});
+
 // ../studio/src/lib/export-settings.ts
 function validateExportSettings(input, meta) {
   const format2 = input.format ?? "h264";
@@ -621,9 +918,9 @@ var init_storyboard = __esm({
 });
 
 // src/storyboard.ts
-import fs2 from "node:fs/promises";
-import path11 from "node:path";
-import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import fs3 from "node:fs/promises";
+import path14 from "node:path";
+import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
 import ts4 from "typescript";
 function literal(n) {
   if (!n) return void 0;
@@ -640,7 +937,7 @@ function literal(n) {
     );
 }
 async function groupInfo(source, relative) {
-  const text = await fs2.readFile(source, "utf8"), ast = ts4.createSourceFile(
+  const text = await fs3.readFile(source, "utf8"), ast = ts4.createSourceFile(
     source,
     text,
     ts4.ScriptTarget.Latest,
@@ -675,7 +972,7 @@ async function groupInfo(source, relative) {
   };
 }
 function createStoryboard(root) {
-  const filename2 = path11.join(root, "storyboard.canvas.json"), cache = path11.join(root, ".osmo/cache/storyboard");
+  const filename2 = path14.join(root, "storyboard.canvas.json"), cache2 = path14.join(root, ".osmo/cache/storyboard");
   let queue = Promise.resolve(), undo = [], redo = [], knownRevision, activeRenderer, closed = false;
   const serial = (fn) => {
     const result = queue.then(fn);
@@ -686,7 +983,7 @@ function createStoryboard(root) {
   async function read() {
     let document;
     try {
-      document = validateBoard(JSON.parse(await fs2.readFile(filename2, "utf8")));
+      document = validateBoard(JSON.parse(await fs3.readFile(filename2, "utf8")));
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
       document = structuredClone(empty);
@@ -703,17 +1000,17 @@ function createStoryboard(root) {
     const result = [];
     async function scan(dir, depth = 0) {
       if (depth > 8 || result.length >= 100) return;
-      for (const e of await fs2.readdir(dir, { withFileTypes: true })) {
+      for (const e of await fs3.readdir(dir, { withFileTypes: true })) {
         if (e.name.startsWith(".") || ["node_modules", "exports", "dist", "target", "assets"].includes(
           e.name
         ))
           continue;
-        const absolute = path11.join(dir, e.name);
+        const absolute = path14.join(dir, e.name);
         if (e.isDirectory()) await scan(absolute, depth + 1);
         else if (e.isFile() && e.name.endsWith(".tsx")) {
           const info2 = await groupInfo(
             absolute,
-            path11.relative(root, absolute).split(path11.sep).join("/")
+            path14.relative(root, absolute).split(path14.sep).join("/")
           );
           if (info2) result.push(info2);
         }
@@ -745,12 +1042,12 @@ function createStoryboard(root) {
     };
   }
   async function write(document) {
-    const temp = `${filename2}.${randomUUID3()}.tmp`;
+    const temp = `${filename2}.${randomUUID6()}.tmp`;
     try {
-      await fs2.writeFile(temp, JSON.stringify(document, null, 2) + "\n");
-      await fs2.rename(temp, filename2);
+      await fs3.writeFile(temp, JSON.stringify(document, null, 2) + "\n");
+      await fs3.rename(temp, filename2);
     } finally {
-      await fs2.rm(temp, { force: true });
+      await fs3.rm(temp, { force: true });
     }
     knownRevision = hash(JSON.stringify(document));
   }
@@ -802,8 +1099,8 @@ function createStoryboard(root) {
       await info(card);
       const { source } = sceneInProject(root, card.source), validation = await check(source);
       if (!validation.ok) throw new Error(validation.errors.join("\n"));
-      await fs2.mkdir(cache, { recursive: true });
-      const name = `${randomUUID3()}.mp4`, destination = path11.join(cache, name);
+      await fs3.mkdir(cache2, { recursive: true });
+      const name = `${randomUUID6()}.mp4`, destination = path14.join(cache2, name);
       const renderer = new Renderer({
         preview: {
           width: card.width,
@@ -819,7 +1116,7 @@ function createStoryboard(root) {
         await renderer.request("export", { destination, supersample: 1 });
         return { name, revision: current.revision };
       } catch (error) {
-        await fs2.rm(destination, { force: true });
+        await fs3.rm(destination, { force: true });
         throw error;
       } finally {
         renderer.close();
@@ -829,7 +1126,7 @@ function createStoryboard(root) {
     video: async (name) => {
       if (!/^[0-9a-f-]{36}\.mp4$/.test(name))
         throw new Error("Invalid preview");
-      return fs2.readFile(path11.join(cache, name));
+      return fs3.readFile(path14.join(cache2, name));
     },
     close() {
       closed = true;
@@ -850,6 +1147,198 @@ var init_storyboard2 = __esm({
   }
 });
 
+// src/asset-metadata.ts
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+import path15 from "node:path";
+async function inspectAsset(file, size) {
+  const metadata = { size };
+  const extension = path15.extname(file).slice(1).toLowerCase();
+  const image = ["png", "jpg", "jpeg", "webp", "gif"].includes(extension);
+  const video = ["mp4", "webm", "mov", "m4v"].includes(extension);
+  const audio = ["wav", "mp3", "m4a", "aac", "ogg", "flac"].includes(extension);
+  if (!image && !video && !audio) return metadata;
+  try {
+    const { stdout } = await exec3(
+      process.env.OSMO_FFPROBE ?? "ffprobe",
+      [
+        "-v",
+        "error",
+        "-protocol_whitelist",
+        "file,pipe",
+        "-show_entries",
+        "stream=codec_type,width,height,avg_frame_rate,duration,sample_rate:stream_disposition=attached_pic:stream_tags=rotate:stream_side_data=rotation:format=duration",
+        "-of",
+        "json",
+        file
+      ],
+      { timeout: 5e3, maxBuffer: 1024 * 1024 }
+    );
+    const data = JSON.parse(stdout);
+    const stream = data.streams?.find(
+      (s) => s.codec_type === (audio ? "audio" : "video") && !s.disposition?.attached_pic
+    );
+    const assign = (key, value) => {
+      const number = Number(value);
+      if (Number.isFinite(number) && number > 0) metadata[key] = number;
+    };
+    if (image || video) {
+      const rotation = Number(
+        stream?.side_data_list?.find(
+          (s) => s.rotation !== void 0
+        )?.rotation ?? stream?.tags?.rotate ?? 0
+      );
+      const portrait = Math.abs(rotation % 180) === 90;
+      assign("width", portrait ? stream?.height : stream?.width);
+      assign("height", portrait ? stream?.width : stream?.height);
+    }
+    if (video) {
+      const [n, d = "1"] = String(stream?.avg_frame_rate).split("/");
+      assign("fps", Number(n) / Number(d));
+    }
+    if (audio || video)
+      assign("duration", stream?.duration ?? data.format?.duration);
+    if (audio) assign("sampleRate", stream?.sample_rate);
+  } catch {
+  }
+  return metadata;
+}
+var exec3;
+var init_asset_metadata = __esm({
+  "src/asset-metadata.ts"() {
+    "use strict";
+    exec3 = promisify3(execFile3);
+  }
+});
+
+// ../editor/src/types.ts
+function nodeKnobs(node) {
+  return node.type === "Composition" && isSceneNode(node.children[0]) ? node.children[0].props.knobs : node.props.knobs;
+}
+function nodeValues(node) {
+  return node.type === "Composition" && isSceneNode(node.children[0]) ? { ...node.children[0].props.values, ...node.props.values } : node.props.values;
+}
+var isSceneNode;
+var init_types = __esm({
+  "../editor/src/types.ts"() {
+    "use strict";
+    isSceneNode = (child) => !!child?.type;
+  }
+});
+
+// ../editor/src/document-assets.ts
+function documentAssetReferences(document) {
+  const assets = [];
+  function resolve(value, scope, seen = /* @__PURE__ */ new Set()) {
+    if (!value?.$ref) return [{ value }];
+    const key = `${value.$ref}:${value.name}`;
+    if (seen.has(key)) throw new Error("Cyclic asset binding");
+    const binding = document.bindings[value.$ref];
+    if (binding?.kind === "knobs")
+      return scope.get(value.$ref)?.get(value.name) ?? [];
+    if (binding?.kind === "motion") {
+      const track = binding.definition[value.name];
+      return [
+        track?.default,
+        ...(track?.keyframes ?? []).map((k) => k.value)
+      ].flatMap(
+        (v) => resolve(v, scope, /* @__PURE__ */ new Set([...seen, key])).map((r) => ({
+          ...r,
+          animated: true
+        }))
+      );
+    }
+    return [];
+  }
+  function add(file, value, kind, scope) {
+    for (const v of resolve(value, scope))
+      if (typeof v.value === "string" && !(kind === "font" && v.value === "Inter")) {
+        if (v.kind && v.kind !== kind)
+          throw new Error(
+            `Knob ${v.knob}: cannot use ${v.kind} asset as ${kind}`
+          );
+        assets.push({
+          file: v.file ?? file,
+          value: v.value,
+          kind,
+          ...v.knob ? { knob: v.knob } : {}
+        });
+      }
+  }
+  function walk(n, parent, override) {
+    const scope = n.type === "Scene" ? /* @__PURE__ */ new Map() : new Map(parent), set = nodeKnobs(n)?.$ref;
+    const schema = document.bindings[set];
+    if (n.type === "Composition") {
+      const child = n.children[0];
+      if (isSceneNode(child))
+        walk(child, parent, { values: n.props.values, file: n.source.file });
+      return;
+    }
+    if (schema?.kind === "knobs") {
+      const values = { ...n.props.values, ...override?.values };
+      scope.set(
+        set,
+        new Map(
+          Object.entries(schema.definition).map(([name, raw]) => {
+            const knob = raw, supplied = values[name] !== void 0;
+            const file = !supplied ? schema.source.file : override?.values?.[name] !== void 0 ? override.file : n.valueSources?.[name] ?? n.source.file;
+            const resolved = resolve(
+              supplied ? values[name] : knob.default,
+              parent
+            );
+            if (knob.type === "asset")
+              for (const v of resolved) {
+                if (v.animated)
+                  throw new Error(
+                    `Knob ${name}: asset bindings must be static`
+                  );
+                if (v.kind && v.kind !== knob.kind)
+                  throw new Error(
+                    `Knob ${name}: cannot bind ${v.kind} to ${knob.kind}`
+                  );
+                if (!validAssetPath(knob.kind, v.value))
+                  throw new Error(
+                    `Knob ${name}: expected a local ${knob.kind} asset path`
+                  );
+              }
+            return [
+              name,
+              resolved.map(
+                (v) => knob.type === "asset" ? {
+                  ...v,
+                  file: v.file ?? v.origin ?? file,
+                  knob: v.knob ?? name,
+                  kind: knob.kind
+                } : { ...v, origin: v.origin ?? file }
+              )
+            ];
+          })
+        )
+      );
+    }
+    if (n.props.src)
+      add(n.sourceFile, n.props.src, n.type.toLowerCase(), scope);
+    if (n.props.font) add(n.sourceFile, n.props.font, "font", scope);
+    for (const c of n.children) if (isSceneNode(c)) walk(c, scope);
+  }
+  walk(
+    document.root,
+    /* @__PURE__ */ new Map(),
+    document.root.type === "Group" && document.preview?.values ? { values: document.preview.values, file: document.entry } : void 0
+  );
+  for (const b of Object.values(document.bindings))
+    if (b.kind === "effect" && b.definition.src)
+      add(b.source.file, b.definition.src, "shader", /* @__PURE__ */ new Map());
+  return assets;
+}
+var init_document_assets = __esm({
+  "../editor/src/document-assets.ts"() {
+    "use strict";
+    init_assets();
+    init_types();
+  }
+});
+
 // ../editor/src/source-path.ts
 function normalize(value) {
   const parts = [];
@@ -869,15 +1358,6 @@ var init_source_path = __esm({
   }
 });
 
-// ../editor/src/types.ts
-var isSceneNode;
-var init_types = __esm({
-  "../editor/src/types.ts"() {
-    "use strict";
-    isSceneNode = (child) => !!child?.type;
-  }
-});
-
 // ../editor/src/scene-document.ts
 import ts5 from "typescript";
 function decodeJsxLiteral(raw, attribute = false) {
@@ -1053,7 +1533,8 @@ function createSceneDocument(entry, files) {
             "opacity",
             "effects",
             "hidden",
-            "solo"
+            "solo",
+            "values"
           ]);
           for (const name of Object.keys(props))
             if (!allowed.has(name))
@@ -1088,6 +1569,7 @@ function createSceneDocument(entry, files) {
               ...props.values ? { values: { ...base.props.values, ...props.values } } : {}
             },
             source: location(opening3),
+            valueSources: { ...base.valueSources, ...Object.fromEntries(Object.keys(props.values ?? {}).map((k) => [k, file])) },
             definition: base.source.file,
             identity: props.id ?? null,
             tag
@@ -1221,7 +1703,7 @@ function outlineDocument(document, meta) {
       ...n.props,
       start: 0,
       ...document.preview?.values ? { values: { ...n.props.values, ...document.preview.values } } : {}
-    } : n.props, local = new Map(scope), set = p.knobs?.$ref, own = document.bindings[set];
+    } : n.props, local = new Map(scope), set = nodeKnobs(n)?.$ref, own = document.bindings[set];
     if (own)
       local.set(
         set,
@@ -1231,7 +1713,7 @@ function outlineDocument(document, meta) {
           ).map(([k, s]) => [
             k,
             resolve(
-              p.values?.[k] ?? s.default,
+              (n.type === "Composition" ? nodeValues(n) : p.values)?.[k] ?? s.default,
               scope,
               clock.offset + (isClipPrimitive2(n.type) && (p.start !== void 0 || p.duration !== void 0 || p.track !== void 0) ? p.start ?? 0 : 0),
               n.id
@@ -1386,12 +1868,13 @@ var init_document_outline = __esm({
 });
 
 // src/scene-document.ts
-import fs3 from "node:fs/promises";
-import path12 from "node:path";
+import fs4 from "node:fs/promises";
+import path16 from "node:path";
 import { createHash as createHash5 } from "node:crypto";
 import ts6 from "typescript";
 function createDocumentLoader(root) {
   const assets = /* @__PURE__ */ new Map();
+  const metadata = /* @__PURE__ */ new Map();
   async function load(source, text, preview = {}, inputs = /* @__PURE__ */ new Map(), includeSources = false) {
     const entry = sceneInProject(root, source).scene, files = {};
     async function read(file, body2, stack = []) {
@@ -1399,7 +1882,7 @@ function createDocumentLoader(root) {
         throw new Error("Cyclic animation imports");
       if (Object.hasOwn(files, file)) return;
       const located = sceneInProject(root, file);
-      files[file] = body2 ?? inputs.get(located.source) ?? await fs3.readFile(located.source, "utf8");
+      files[file] = body2 ?? inputs.get(located.source) ?? await fs4.readFile(located.source, "utf8");
       const ast = ts6.createSourceFile(
         file,
         files[file],
@@ -1423,49 +1906,24 @@ function createDocumentLoader(root) {
     const document = createSceneDocument(entry, files);
     document.preview = preview;
     document.assets = {};
-    async function asset(file, value, kind) {
-      if (value?.$ref) {
-        const binding = document.bindings[value.$ref]?.definition?.[value.name];
-        if (binding)
-          for (const v of [
-            binding.default,
-            ...(binding.keyframes ?? []).map((k) => k.value)
-          ])
-            await asset(file, v, kind);
-        return;
-      }
-      if (typeof value !== "string" || kind === "font" && value === "Inter")
-        return;
-      const relative = path12.posix.normalize(
-        path12.posix.join(path12.posix.dirname(file), value)
-      );
-      if (document.assets[relative]) return;
-      document.assets[relative] = await registerAsset(relative, kind);
-    }
-    async function walk(n) {
-      try {
-        if (n.props.src)
-          await asset(
-            n.sourceFile,
-            n.props.src,
-            n.type === "Shader" ? "shader" : n.type.toLowerCase()
-          );
-        if (n.props.font) await asset(n.sourceFile, n.props.font, "font");
-      } catch (error) {
-        document.nativeReason = `Asset unavailable for browser preview: ${error.message}`;
+    try {
+      for (const ref of documentAssetReferences(document)) {
+        const relative = path16.posix.normalize(path16.posix.join(path16.posix.dirname(ref.file), ref.value));
+        if (document.assets[relative]) continue;
+        try {
+          document.assets[relative] = await registerAsset(relative, ref.kind);
+        } catch (error) {
+          throw new Error(`${ref.knob ? `Knob ${ref.knob}: ` : ""}${relative}: ${error.message}`);
+        }
       }
-      for (const c of n.children)
-        if (c?.type) await walk(c);
+    } catch (error) {
+      document.nativeReason = `Asset unavailable for browser preview: ${error.message}`;
     }
-    for (const binding of Object.values(document.bindings))
-      if (binding.kind === "effect" && binding.definition.src)
-        await asset(binding.source.file, binding.definition.src, "shader");
-    await walk(document.root);
     while (assets.size > 1e3) assets.delete(assets.keys().next().value);
     return { ...document, ...includeSources ? { sourceFiles: files } : {} };
   }
   async function registerAsset(relative, kind) {
-    const located = sceneInProject(root, relative), info = await fs3.stat(located.source);
+    const located = sceneInProject(root, relative), info = await fs4.stat(located.source);
     if (!info.isFile()) throw new Error(`Asset is not a file: ${relative}`);
     const id = createHash5("sha256").update(located.source + "\0" + info.mtimeMs + "\0" + info.size).digest("hex");
     assets.set(id, {
@@ -1476,7 +1934,7 @@ function createDocumentLoader(root) {
     const asset = { id, kind };
     if (kind === "shader") {
       if (info.size > 1024 * 1024) throw new Error("Shader exceeds 1 MB");
-      asset.code = await fs3.readFile(located.source, "utf8");
+      asset.code = await fs4.readFile(located.source, "utf8");
     }
     return asset;
   }
@@ -1521,26 +1979,40 @@ function createDocumentLoader(root) {
       }
     return { resources: resources2, errors };
   }
-  async function readAsset(id) {
+  async function locateAsset(id) {
     const asset = assets.get(id);
     if (!asset)
       throw Object.assign(new Error("Unknown scene asset"), { status: 404 });
-    const current = sceneInProject(root, asset.file), info = await fs3.stat(current.source);
+    const current = sceneInProject(root, asset.file), info = await fs4.stat(current.source);
     if (current.source !== asset.file || info.size !== asset.size || info.mtimeMs !== asset.mtime)
       throw Object.assign(
         new Error("Scene asset changed. Refresh the scene."),
         { status: 409 }
       );
+    return { file: current.source, size: info.size };
+  }
+  async function readAsset(id) {
+    const current = await locateAsset(id);
     return {
-      bytes: await fs3.readFile(current.source),
-      extension: path12.extname(current.source).toLowerCase()
+      bytes: await fs4.readFile(current.file),
+      extension: path16.extname(current.file).toLowerCase()
     };
   }
-  return { load, readAsset, resources };
+  async function assetMetadata(id) {
+    const current = await locateAsset(id);
+    if (!metadata.has(id))
+      metadata.set(id, inspectAsset(current.file, current.size));
+    while (metadata.size > 1e3)
+      metadata.delete(metadata.keys().next().value);
+    return metadata.get(id);
+  }
+  return { load, readAsset, resources, registerAsset, assetMetadata };
 }
 var init_scene_document2 = __esm({
   "src/scene-document.ts"() {
     "use strict";
+    init_asset_metadata();
+    init_document_assets();
     init_runtime();
     init_scene_document();
     init_document_outline();
@@ -1548,30 +2020,30 @@ var init_scene_document2 = __esm({
 });
 
 // src/project-resources.ts
-import fs4 from "node:fs/promises";
-import path13 from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
+import fs5 from "node:fs/promises";
+import path17 from "node:path";
+import { execFile as execFile4 } from "node:child_process";
+import { promisify as promisify4 } from "node:util";
 import ts7 from "typescript";
 async function resourceFile(root, relative) {
-  if (typeof relative !== "string" || path13.isAbsolute(relative))
+  if (typeof relative !== "string" || path17.isAbsolute(relative))
     throw new Error("Resource paths must be relative.");
-  const base = await fs4.realpath(root), file = await fs4.realpath(path13.resolve(base, relative));
-  if (!inside(path13.join(base, "resources"), file) || (await fs4.stat(file)).isDirectory())
+  const base = await fs5.realpath(root), file = await fs5.realpath(path17.resolve(base, relative));
+  if (!inside(path17.join(base, "resources"), file) || (await fs5.stat(file)).isDirectory())
     throw new Error("Resource files must stay inside resources/.");
   return file;
 }
 async function resourceFolder(root) {
-  const base = await fs4.realpath(root), folder = path13.join(base, "resources");
-  await fs4.mkdir(folder, { recursive: true });
-  if ((await fs4.lstat(folder)).isSymbolicLink())
+  const base = await fs5.realpath(root), folder = path17.join(base, "resources");
+  await fs5.mkdir(folder, { recursive: true });
+  if ((await fs5.lstat(folder)).isSymbolicLink())
     throw new Error("resources/ must be a real directory.");
   return folder;
 }
 async function listProjectResources(root) {
   let entries;
   try {
-    entries = await fs4.readdir(path13.join(root, "resources"), {
+    entries = await fs5.readdir(path17.join(root, "resources"), {
       withFileTypes: true
     });
   } catch (e) {
@@ -1583,12 +2055,12 @@ async function listProjectResources(root) {
     if (item.name.startsWith(".") || !item.isDirectory()) continue;
     try {
       const relative = `resources/${item.name}/resource.json`, manifestFile = await resourceFile(root, relative);
-      if ((await fs4.stat(manifestFile)).size > 1024 * 1024)
+      if ((await fs5.stat(manifestFile)).size > 1024 * 1024)
         throw new Error("Manifest exceeds 1 MB");
-      const meta = JSON.parse(await fs4.readFile(manifestFile, "utf8"));
+      const meta = JSON.parse(await fs5.readFile(manifestFile, "utf8"));
       const entry = `resources/${item.name}/${meta.entry}`, file = await resourceFile(root, entry);
-      const kind = meta.kind ?? (meta.category === "3d" ? "model" : meta.category) ?? kinds[path13.extname(file).toLowerCase()];
-      if (!["shader", "image", "video", "model", "scene"].includes(kind) || kinds[path13.extname(file).toLowerCase()] !== kind)
+      const kind = meta.kind ?? (meta.category === "3d" ? "model" : meta.category) ?? kinds[path17.extname(file).toLowerCase()];
+      if (!["shader", "image", "video", "model", "scene"].includes(kind) || kinds[path17.extname(file).toLowerCase()] !== kind)
         throw new Error("Unsupported resource type");
       let effect;
       if (kind === "shader" && meta.effect) {
@@ -1606,7 +2078,7 @@ async function listProjectResources(root) {
       const dimensions = Object.fromEntries(
         ["width", "height", "duration"].filter((k) => Number.isFinite(meta[k]) && meta[k] > 0).map((k) => [k, meta[k]])
       );
-      const info = await fs4.stat(file), preview = meta.preview ? `resources/${item.name}/${meta.preview}` : ["image", "video"].includes(kind) ? entry : null;
+      const info = await fs5.stat(file), preview = meta.preview ? `resources/${item.name}/${meta.preview}` : ["image", "video"].includes(kind) ? entry : null;
       if (preview) await resourceFile(root, preview);
       resources.push({
         id: item.name,
@@ -1621,7 +2093,7 @@ async function listProjectResources(root) {
         } : {},
         preview: preview && (meta.preview || info.size < 12 * 1024 * 1024) ? preview : null,
         previewType: meta.preview ? "image" : kind,
-        stamp: `${info.mtimeMs}:${info.size}:${(await fs4.stat(manifestFile)).mtimeMs}`
+        stamp: `${info.mtimeMs}:${info.size}:${(await fs5.stat(manifestFile)).mtimeMs}`
       });
     } catch (error) {
       if (error.code !== "ENOENT")
@@ -1630,7 +2102,7 @@ async function listProjectResources(root) {
   }
   async function scenes(folder, depth = 0) {
     if (depth > 16) return;
-    for (const item of await fs4.readdir(folder, { withFileTypes: true })) {
+    for (const item of await fs5.readdir(folder, { withFileTypes: true })) {
       if (item.name.startsWith(".") || [
         "node_modules",
         "dist",
@@ -1639,16 +2111,16 @@ async function listProjectResources(root) {
         "video-references"
       ].includes(item.name) || item.isSymbolicLink())
         continue;
-      const file = path13.join(folder, item.name);
+      const file = path17.join(folder, item.name);
       if (item.isDirectory()) {
         await scenes(file, depth + 1);
         continue;
       }
-      if (!item.isFile() || !item.name.endsWith(".tsx") || (await fs4.stat(file)).size > 1024 * 1024)
+      if (!item.isFile() || !item.name.endsWith(".tsx") || (await fs5.stat(file)).size > 1024 * 1024)
         continue;
-      const entry = path13.relative(root, file).split(path13.sep).join("/");
+      const entry = path17.relative(root, file).split(path17.sep).join("/");
       try {
-        const text = await fs4.readFile(file, "utf8"), ast = ts7.createSourceFile(
+        const text = await fs5.readFile(file, "utf8"), ast = ts7.createSourceFile(
           entry,
           text,
           ts7.ScriptTarget.Latest,
@@ -1685,12 +2157,12 @@ async function listProjectResources(root) {
         else
           resources.push({
             id: `scene:${entry}`,
-            title: item.name === "scene.tsx" ? path13.basename(folder) : item.name.slice(0, -4),
+            title: item.name === "scene.tsx" ? path17.basename(folder) : item.name.slice(0, -4),
             kind: "scene",
             entry,
             ...info,
             preview: null,
-            stamp: String((await fs4.stat(file)).mtimeMs)
+            stamp: String((await fs5.stat(file)).mtimeMs)
           });
       } catch (error) {
         errors.push(`${entry}: ${error.message}`);
@@ -1709,44 +2181,44 @@ async function getProjectResource(root, id) {
 async function resourcePreview(root, id) {
   const resource = await getProjectResource(root, id);
   if (!resource.preview) throw new Error("No preview for this resource");
-  const file = await resourceFile(root, resource.preview), type = mime[path13.extname(file).toLowerCase()];
+  const file = await resourceFile(root, resource.preview), type = mime[path17.extname(file).toLowerCase()];
   if (!type) throw new Error("Unsupported preview type");
-  if ((await fs4.stat(file)).size > 12 * 1024 * 1024)
+  if ((await fs5.stat(file)).size > 12 * 1024 * 1024)
     throw new Error("Preview is too large");
-  return { bytes: await fs4.readFile(file), type };
+  return { bytes: await fs5.readFile(file), type };
 }
 async function installResourceExamples(root) {
-  const folder = await resourceFolder(root), source = path13.join(packageRoot, "src/resource-examples/");
-  for (const item of await fs4.readdir(source, { withFileTypes: true })) {
+  const folder = await resourceFolder(root), source = path17.join(packageRoot, "src/resource-examples/");
+  for (const item of await fs5.readdir(source, { withFileTypes: true })) {
     if (!item.isDirectory()) continue;
-    const destination = path13.join(folder, item.name);
+    const destination = path17.join(folder, item.name);
     try {
-      await fs4.mkdir(destination);
+      await fs5.mkdir(destination);
     } catch (e) {
       if (e.code === "EEXIST") continue;
       throw e;
     }
     try {
-      for (const file of (await fs4.readdir(path13.join(source, item.name))).sort(
+      for (const file of (await fs5.readdir(path17.join(source, item.name))).sort(
         (a, b) => Number(a === "resource.json") - Number(b === "resource.json")
       ))
-        await fs4.copyFile(
-          path13.join(source, item.name, file),
-          path13.join(destination, file)
+        await fs5.copyFile(
+          path17.join(source, item.name, file),
+          path17.join(destination, file)
         );
     } catch (error) {
-      await fs4.rm(destination, { recursive: true, force: true });
+      await fs5.rm(destination, { recursive: true, force: true });
       throw error;
     }
   }
   return { status: "installed", ...await listProjectResources(root) };
 }
-var exec, kinds, mime, inside;
+var exec4, kinds, mime, inside;
 var init_project_resources = __esm({
   "src/project-resources.ts"() {
     "use strict";
     init_runtime();
-    exec = promisify(execFile);
+    exec4 = promisify4(execFile4);
     kinds = {
       ".tsx": "scene",
       ".svg": "image",
@@ -1771,8 +2243,8 @@ var init_project_resources = __esm({
       ".mov": "video/quicktime"
     };
     inside = (root, file) => {
-      const rel = path13.relative(root, file);
-      return rel !== ".." && !rel.startsWith(".." + path13.sep) && !path13.isAbsolute(rel);
+      const rel = path17.relative(root, file);
+      return rel !== ".." && !rel.startsWith(".." + path17.sep) && !path17.isAbsolute(rel);
     };
   }
 });
@@ -2033,7 +2505,7 @@ function validProperty(name, value, spec) {
   if (["position", "origin"].includes(name)) return pair(value);
   if (name === "rotation" && spec.kind === "json")
     return Array.isArray(value) && value.length === 3 && value.every(number);
-  if (name === "scale") return number(value) || pair(value);
+  if (name === "scale") return number(value);
   if (["width", "height"].includes(name))
     return value === "fill" || value === "auto" || number(value) && value > 0;
   if (name === "padding")
@@ -2041,6 +2513,7 @@ function validProperty(name, value, spec) {
   return false;
 }
 function validKnob(schema, value) {
+  if (schema.type === "asset") return !!schema.kind && validAssetPath(schema.kind, value);
   if (schema.type === "text")
     return typeof value === "string" && value.length <= 1e4;
   if (schema.type === "color")
@@ -2061,6 +2534,7 @@ function validKnob(schema, value) {
 var init_property_validation = __esm({
   "../editor/src/property-validation.ts"() {
     "use strict";
+    init_assets();
     init_mask();
   }
 });
@@ -2756,6 +3230,30 @@ function applyTimelineCommand(text, command, {
       { start: clip.node.getStart(model.ast), end: clip.node.end, text: "" }
     ]);
     id = null;
+  } else if (command.type === "split") {
+    const at = command.time, cut = at - clip.start, value = (name, fallback) => {
+      const attr = clip.attrs.get(name);
+      if (!attr) return fallback;
+      const read = literal2(attr.initializer);
+      if (!read.known || typeof read.value !== "number")
+        throw new Error(`This clip's ${name} is set in code; edit it there`);
+      return read.value;
+    };
+    const copy = copyClip(
+      clip,
+      model.ast,
+      {
+        start: at,
+        duration: clip.duration - cut,
+        trimIn: value("trimIn", 0) + cut * value("playbackRate", 1)
+      },
+      fresh
+    );
+    id = copy.id;
+    text = patches(text, [
+      { start: clip.node.end, end: clip.node.end, text: "\n  " + copy.text }
+    ]);
+    text = setAttrs(text, clip.node, { duration: cut }, model.ast);
   } else if (command.type === "duplicate") {
     let start = clip.start + clip.duration, track = clip.track;
     if (!canPlace(model.clips, null, start, clip.duration, track, model.duration)) {
@@ -2871,7 +3369,7 @@ var init_timeline = __esm({
       position: { kind: "json", default: [0, 0] },
       z: { kind: "number", default: 0 },
       rotation: { kind: "number", default: 0 },
-      scale: { kind: "json", default: 1 },
+      scale: { kind: "number", default: 1 },
       origin: { kind: "json", default: [0, 0] },
       width: { kind: "json", default: "fill" },
       height: { kind: "json", default: "fill" },
@@ -3143,10 +3641,10 @@ var init_resource_source = __esm({
 });
 
 // src/timeline-editor.ts
-import fs5 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import { realpathSync } from "node:fs";
-import path14 from "node:path";
-import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
+import path18 from "node:path";
+import { createHash as createHash6, randomUUID as randomUUID7 } from "node:crypto";
 import ts10 from "typescript";
 function createTimelineEditor(root, context, {
   nativeValidation = false,
@@ -3164,8 +3662,8 @@ function createTimelineEditor(root, context, {
   };
   async function read() {
     const { source: inputSource, scene } = context();
-    const source = await fs5.realpath(inputSource);
-    const text = await fs5.readFile(source, "utf8"), definitions = {}, inputs = /* @__PURE__ */ new Map([[source, text]]);
+    const source = await fs6.realpath(inputSource);
+    const text = await fs6.readFile(source, "utf8"), definitions = {}, inputs = /* @__PURE__ */ new Map([[source, text]]);
     async function dependencies(file, body2, depth = 0) {
       if (depth > 32) throw new Error("Too many imported animations");
       const ast = ts10.createSourceFile(
@@ -3184,7 +3682,7 @@ function createTimelineEditor(root, context, {
           );
           let code = inputs.get(next.source);
           if (code === void 0) {
-            code = await fs5.readFile(next.source, "utf8");
+            code = await fs6.readFile(next.source, "utf8");
             inputs.set(next.source, code);
             await dependencies(next.source, code, depth + 1);
           }
@@ -3233,7 +3731,7 @@ function createTimelineEditor(root, context, {
       ...data,
       sourceFiles: Object.fromEntries(
         [...inputs].map(([file, body2]) => [
-          path14.relative(root, file).split(path14.sep).join("/"),
+          path18.relative(root, file).split(path18.sep).join("/"),
           body2
         ])
       ),
@@ -3244,16 +3742,16 @@ function createTimelineEditor(root, context, {
     };
   }
   async function write(file, text) {
-    const temp = path14.join(
-      path14.dirname(file),
-      `.osmo-edit-${randomUUID4()}.tmp`
+    const temp = path18.join(
+      path18.dirname(file),
+      `.osmo-edit-${randomUUID7()}.tmp`
     );
     try {
-      const mode = (await fs5.stat(file)).mode;
-      await fs5.writeFile(temp, text, { mode });
-      await fs5.rename(temp, file);
+      const mode = (await fs6.stat(file)).mode;
+      await fs6.writeFile(temp, text, { mode });
+      await fs6.rename(temp, file);
     } finally {
-      await fs5.rm(temp, { force: true });
+      await fs6.rm(temp, { force: true });
     }
   }
   return {
@@ -3266,27 +3764,27 @@ function createTimelineEditor(root, context, {
     resolveAdd: (cardId) => serial(async () => {
       const board = validateBoard(
         JSON.parse(
-          await fs5.readFile(
-            path14.join(root, "storyboard.canvas.json"),
+          await fs6.readFile(
+            path18.join(root, "storyboard.canvas.json"),
             "utf8"
           )
         )
       );
       const card = board.cards.find((c) => c.id === cardId);
       if (!card) throw new Error("Storyboard card no longer exists");
-      const located = sceneInProject(root, card.source), code = await fs5.readFile(located.source, "utf8");
+      const located = sceneInProject(root, card.source), code = await fs6.readFile(located.source, "utf8");
       const document = await documentLoader.load(located.source, code);
       const sourceFiles = Object.fromEntries(
         await Promise.all(
           document.files.map(
             async (file) => [
               file,
-              await fs5.readFile(sceneInProject(root, file).source, "utf8")
+              await fs6.readFile(sceneInProject(root, file).source, "utf8")
             ]
           )
         )
       );
-      let importPath = path14.relative(path14.dirname(context().source), located.source).split(path14.sep).join("/");
+      let importPath = path18.relative(path18.dirname(context().source), located.source).split(path18.sep).join("/");
       if (!importPath.startsWith(".")) importPath = "./" + importPath;
       return {
         type: "add",
@@ -3326,7 +3824,7 @@ function createTimelineEditor(root, context, {
         if (typeof change.file !== "string" || !change.file.endsWith(".tsx") || typeof change.after !== "string" || change.after.length > 1024 * 1024)
           throw new Error("Invalid source patch");
         const file = sceneInProject(root, change.file).source;
-        const current2 = await fs5.readFile(file, "utf8");
+        const current2 = await fs6.readFile(file, "utf8");
         if (current2 !== change.before)
           throw Object.assign(new Error(`Source changed: ${change.file}`), {
             status: 409
@@ -3360,7 +3858,7 @@ function createTimelineEditor(root, context, {
           status: 409
         });
       for (const change of changed)
-        if (await fs5.readFile(change.file, "utf8") !== change.before)
+        if (await fs6.readFile(change.file, "utf8") !== change.before)
           throw Object.assign(new Error("Source changed while validating"), {
             status: 409
           });
@@ -3372,7 +3870,7 @@ function createTimelineEditor(root, context, {
         }
       } catch (error) {
         for (const change of written.reverse())
-          if (await fs5.readFile(change.file, "utf8") === change.after)
+          if (await fs6.readFile(change.file, "utf8") === change.after)
             await write(change.file, change.before);
         throw error;
       }
@@ -3435,15 +3933,15 @@ function createTimelineEditor(root, context, {
         if (!before.inputs.has(file))
           throw new Error("Target source is not part of this scene");
         const relative = (value) => {
-          let p = path14.relative(path14.dirname(file), sceneInProject(root, value).source).split(path14.sep).join("/");
+          let p = path18.relative(path18.dirname(file), sceneInProject(root, value).source).split(path18.sep).join("/");
           return p.startsWith(".") ? p : "./" + p;
         };
         result = applyResourceSource(before.inputs.get(file), plan, {
-          filename: path14.relative(root, file),
+          filename: path18.relative(root, file),
           definitions: before.definitions,
           src: relative(resource.entry),
           effectSrc: resource.effect ? relative(resource.effect.src) : void 0,
-          newId: () => `clip-${randomUUID4().slice(0, 8)}`
+          newId: () => `clip-${randomUUID7().slice(0, 8)}`
         });
       } else if (command.type === "group") {
         const target = findGroup(before.document, command.nodeId);
@@ -3463,8 +3961,8 @@ function createTimelineEditor(root, context, {
         if (command.type === "add") {
           const board = validateBoard(
             JSON.parse(
-              await fs5.readFile(
-                path14.join(root, "storyboard.canvas.json"),
+              await fs6.readFile(
+                path18.join(root, "storyboard.canvas.json"),
                 "utf8"
               )
             )
@@ -3473,12 +3971,12 @@ function createTimelineEditor(root, context, {
           const { source: groupSource, scene: groupScene } = sceneInProject(
             root,
             card.source
-          ), code = await fs5.readFile(groupSource, "utf8");
+          ), code = await fs6.readFile(groupSource, "utf8");
           const definition = {
             ...describeGroup(code, groupScene),
             source: groupScene
           };
-          let importPath = path14.relative(path14.dirname(before.source), groupSource).split(path14.sep).join("/");
+          let importPath = path18.relative(path18.dirname(before.source), groupSource).split(path18.sep).join("/");
           if (!importPath.startsWith(".")) importPath = "./" + importPath;
           resolved = {
             type: "add",
@@ -3491,7 +3989,7 @@ function createTimelineEditor(root, context, {
         result = applyTimelineCommand(before.text, resolved, {
           definitions: before.definitions,
           filename: before.scene,
-          newId: () => `clip-${randomUUID4().slice(0, 8)}`
+          newId: () => `clip-${randomUUID7().slice(0, 8)}`
         });
       }
       if (result.text === before.inputs.get(file))
@@ -3590,8 +4088,8 @@ var init_timeline_editor = __esm({
     init_resource_source();
     init_timeline();
     init_group_model();
-    resolveImport = (source, spec) => path14.resolve(
-      path14.dirname(source),
+    resolveImport = (source, spec) => path18.resolve(
+      path18.dirname(source),
       spec.endsWith(".tsx") ? spec : spec.endsWith(".js") ? spec.slice(0, -3) + ".tsx" : spec + ".tsx"
     );
     hash2 = (value) => createHash6("sha256").update(value).digest("hex");
@@ -3599,17 +4097,17 @@ var init_timeline_editor = __esm({
 });
 
 // src/studio-settings.ts
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile6, rename as rename3, rm as rm6 } from "node:fs/promises";
-import path15 from "node:path";
+import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile7, rename as rename3, rm as rm7 } from "node:fs/promises";
+import path19 from "node:path";
 import { randomBytes } from "node:crypto";
 async function studioSettings(root) {
-  const directory = path15.join(root, ".osmo");
-  await mkdir6(directory, { recursive: true });
-  const lock = path15.join(directory, "studio.lock");
+  const directory = path19.join(root, ".osmo");
+  await mkdir7(directory, { recursive: true });
+  const lock = path19.join(directory, "studio.lock");
   const deadline = Date.now() + 5e3;
   while (true) {
     try {
-      await mkdir6(lock);
+      await mkdir7(lock);
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
@@ -3620,12 +4118,12 @@ async function studioSettings(root) {
       await new Promise((resolve) => setTimeout(resolve, 50));
     }
   }
-  const release = () => rm6(lock, { recursive: true, force: true });
+  const release = () => rm7(lock, { recursive: true, force: true });
   try {
-    const file = path15.join(directory, "studio.json");
+    const file = path19.join(directory, "studio.json");
     let settings, existing = false;
     try {
-      settings = JSON.parse(await readFile7(file, "utf8"));
+      settings = JSON.parse(await readFile8(file, "utf8"));
       existing = true;
       if (settings.version !== 1 || typeof settings.id !== "string" || settings.id.length > 64 || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(settings.id) || !/^[a-f0-9]{48}$/.test(settings.token) || !Number.isInteger(settings.port) || settings.port < 1 || settings.port > 65535)
         throw new Error("Invalid settings");
@@ -3634,7 +4132,7 @@ async function studioSettings(root) {
         throw new Error(
           "Cannot read .osmo/studio.json. Fix or remove it to reset the Studio address."
         );
-      const name = path15.basename(root).normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 48).replace(/-$/, "") || "project";
+      const name = path19.basename(root).normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 48).replace(/-$/, "") || "project";
       settings = {
         version: 1,
         id: `${name}-${randomBytes(2).toString("hex")}`,
@@ -3642,10 +4140,10 @@ async function studioSettings(root) {
         token: randomBytes(24).toString("hex")
       };
     }
-    const ignorePath = path15.join(root, ".gitignore");
+    const ignorePath = path19.join(root, ".gitignore");
     let ignore = "";
     try {
-      ignore = await readFile7(ignorePath, "utf8");
+      ignore = await readFile8(ignorePath, "utf8");
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
@@ -3655,7 +4153,7 @@ async function studioSettings(root) {
       ".osmo/studio.*.tmp"
     ].filter((rule) => !ignore.split("\n").includes(rule));
     if (missing.length)
-      await writeFile6(
+      await writeFile7(
         ignorePath,
         ignore + (ignore && !ignore.endsWith("\n") ? "\n" : "") + missing.join("\n") + "\n"
       );
@@ -3666,12 +4164,12 @@ async function studioSettings(root) {
       async save() {
         const temp = `${file}.${process.pid}.tmp`;
         try {
-          await writeFile6(temp, JSON.stringify(settings, null, 2) + "\n", {
+          await writeFile7(temp, JSON.stringify(settings, null, 2) + "\n", {
             mode: 384
           });
           await rename3(temp, file);
         } finally {
-          await rm6(temp, { force: true });
+          await rm7(temp, { force: true });
         }
       }
     };
@@ -3687,14 +4185,14 @@ var init_studio_settings = __esm({
 });
 
 // src/comment-profile.ts
-import { readFile as readFile8, writeFile as writeFile7, rename as rename4, mkdir as mkdir7 } from "node:fs/promises";
+import { readFile as readFile9, writeFile as writeFile8, rename as rename4, mkdir as mkdir8 } from "node:fs/promises";
 import { userInfo } from "node:os";
-import { randomUUID as randomUUID5 } from "node:crypto";
-import path16 from "node:path";
+import { randomUUID as randomUUID8 } from "node:crypto";
+import path20 from "node:path";
 async function commentProfile(root) {
   try {
     const profile = JSON.parse(
-      await readFile8(path16.join(root, ".osmo/comment-profile.json"), "utf8")
+      await readFile9(path20.join(root, ".osmo/comment-profile.json"), "utf8")
     );
     if (!validAuthor(profile)) throw new Error("Invalid comment profile");
     return profile;
@@ -3713,11 +4211,11 @@ async function saveCommentProfile(root, input) {
     throw new Error(
       "Provide a name and a PNG, JPEG, or WebP avatar under 110 KB."
     );
-  const folder = path16.join(root, ".osmo");
-  await mkdir7(folder, { recursive: true });
-  const temp = path16.join(folder, `comment-profile.${randomUUID5()}.tmp`);
-  await writeFile7(temp, JSON.stringify(profile) + "\n");
-  await rename4(temp, path16.join(folder, "comment-profile.json"));
+  const folder = path20.join(root, ".osmo");
+  await mkdir8(folder, { recursive: true });
+  const temp = path20.join(folder, `comment-profile.${randomUUID8()}.tmp`);
+  await writeFile8(temp, JSON.stringify(profile) + "\n");
+  await rename4(temp, path20.join(folder, "comment-profile.json"));
   return profile;
 }
 var init_comment_profile = __esm({
@@ -3733,16 +4231,16 @@ __export(server_exports, {
   startStudio: () => startStudio
 });
 import http from "node:http";
-import fs6 from "node:fs";
-import { readFile as readFile9, stat, realpath, readdir as readdir3 } from "node:fs/promises";
-import path17 from "node:path";
-import { createHash as createHash7, randomUUID as randomUUID6 } from "node:crypto";
+import fs7 from "node:fs";
+import { readFile as readFile10, stat as stat3, realpath as realpath3, readdir as readdir3 } from "node:fs/promises";
+import path21 from "node:path";
+import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
 import { spawn as spawn3 } from "node:child_process";
 async function revision(paths) {
   const hash3 = createHash7("sha256");
   for (const file of [...new Set(paths)].sort()) {
     hash3.update(file);
-    for await (const chunk of fs6.createReadStream(file)) hash3.update(chunk);
+    for await (const chunk of fs7.createReadStream(file)) hash3.update(chunk);
   }
   return `sha256:${hash3.digest("hex")}`;
 }
@@ -3750,7 +4248,7 @@ async function fingerprint(paths) {
   return Promise.all(
     paths.map(async (p) => {
       try {
-        const s = await stat(p);
+        const s = await stat3(p);
         return `${p}:${s.mtimeMs}:${s.size}`;
       } catch {
         return p + ":missing";
@@ -3759,7 +4257,7 @@ async function fingerprint(paths) {
   ).then((v) => v.join("|"));
 }
 async function studioRevision() {
-  const files = (await readdir3(studioRoot, { recursive: true })).filter((file) => /\.(html|js|css|svg|woff2|wasm)$/.test(file)).sort().map((file) => path17.join(studioRoot, file));
+  const files = (await readdir3(studioRoot, { recursive: true })).filter((file) => /\.(html|js|css|svg|woff2|wasm)$/.test(file)).sort().map((file) => path21.join(studioRoot, file));
   const stamp = await fingerprint(files);
   if (stamp !== studioStamp) {
     const digest = await revision(files);
@@ -3797,10 +4295,10 @@ async function startStudio({
   preview = {},
   open = true
 }) {
-  const studioBuild = path17.join(runtimeRoot, "packages/studio/tools/build.mjs");
-  if (fs6.existsSync(studioBuild)) await run(process.execPath, [studioBuild]);
-  root = await realpath(root);
-  source = await realpath(source);
+  const studioBuild = path21.join(runtimeRoot, "packages/studio/tools/build.mjs");
+  if (fs7.existsSync(studioBuild)) await run(process.execPath, [studioBuild]);
+  root = await realpath3(root);
+  source = await realpath3(source);
   const profile = await studioSettings(root);
   const { settings } = profile, { token } = settings;
   const projectPath = "/" + settings.id;
@@ -3832,7 +4330,7 @@ async function startStudio({
     scene,
     preview,
     version,
-    projectName: path17.basename(root),
+    projectName: path21.basename(root),
     projectId: settings.id,
     loading: true,
     error: null,
@@ -3845,10 +4343,10 @@ async function startStudio({
   const watchedStamps = /* @__PURE__ */ new Map();
   watchedStamps.set(source, await fingerprint([source]));
   const geometryCache = /* @__PURE__ */ new Map(), geometryInflight = /* @__PURE__ */ new Map();
-  const cache = /* @__PURE__ */ new Map(), inflight = /* @__PURE__ */ new Map();
+  const cache2 = /* @__PURE__ */ new Map(), inflight = /* @__PURE__ */ new Map();
   let cacheBytes = 0;
   function clearFrames() {
-    cache.clear();
+    cache2.clear();
     cacheBytes = 0;
     geometryCache.clear();
   }
@@ -4000,16 +4498,68 @@ async function startStudio({
           return json(res, 403, {
             error: "Open the Studio URL printed by the CLI."
           });
+        if (req.method === "POST" && url2.pathname === "/api/attachments/pick")
+          return json(res, 200, await pickLocalAttachments());
+        const selection = url2.pathname.match(
+          /^\/api\/attachments\/selected\/([a-f0-9-]+)$/
+        );
+        if (req.method === "GET" && selection) {
+          const file2 = selectedLocalAttachment(selection[1]);
+          if (url2.searchParams.get("preview") === "1") {
+            const bytes2 = await attachmentThumbnail(file2.sourcePath);
+            res.writeHead(200, {
+              "Content-Type": "image/jpeg",
+              "Cache-Control": "private, max-age=60"
+            });
+            return res.end(bytes2);
+          }
+          res.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "X-Content-Type-Options": "nosniff"
+          });
+          const stream = fs7.createReadStream(file2.sourcePath);
+          res.once("close", () => stream.destroy());
+          stream.on("error", () => res.destroy()).pipe(res);
+          return;
+        }
+        if (req.method === "POST" && url2.pathname === "/api/assets/import") {
+          const kind = url2.searchParams.get("kind") ?? "";
+          const relative = await importProjectAsset(
+            root,
+            req,
+            url2.searchParams.get("name") ?? "",
+            kind
+          );
+          return json(res, 200, {
+            path: relative,
+            asset: await documentLoader.registerAsset(relative, kind)
+          });
+        }
+        if (req.method === "GET" && url2.pathname === "/api/assets/metadata")
+          return json(
+            res,
+            200,
+            await documentLoader.assetMetadata(url2.searchParams.get("id"))
+          );
         if (req.method === "GET" && url2.pathname === "/api/document/asset") {
           const asset = await documentLoader.readAsset(
             url2.searchParams.get("id")
           );
-          const types2 = {
+          const types3 = {
             ".svg": "image/svg+xml",
             ".png": "image/png",
             ".jpg": "image/jpeg",
             ".jpeg": "image/jpeg",
             ".webp": "image/webp",
+            ".gif": "image/gif",
+            ".wav": "audio/wav",
+            ".mp3": "audio/mpeg",
+            ".m4a": "audio/mp4",
+            ".aac": "audio/aac",
+            ".ogg": "audio/ogg",
+            ".flac": "audio/flac",
+            ".m4v": "video/mp4",
+            ".glb": "model/gltf-binary",
             ".mp4": "video/mp4",
             ".webm": "video/webm",
             ".mov": "video/quicktime",
@@ -4017,7 +4567,7 @@ async function startStudio({
             ".otf": "font/otf"
           };
           res.writeHead(200, {
-            "Content-Type": types2[asset.extension] ?? "application/octet-stream",
+            "Content-Type": types3[asset.extension] ?? "application/octet-stream",
             "Cache-Control": "private, max-age=31536000, immutable"
           });
           return res.end(asset.bytes);
@@ -4138,7 +4688,7 @@ async function startStudio({
             renderer?.close();
             renderer = null;
             nativeRevision = null;
-            source = await realpath(next.source);
+            source = await realpath3(next.source);
             scene = next.scene;
             state.scene = scene;
             dependencies = [source];
@@ -4208,14 +4758,14 @@ async function startStudio({
             geometry = {
               revision: rev,
               frame,
-              targets: result.targets.filter((t) => rows.has(t.path)).map(({ path: path19, ...t }, order) => ({
+              targets: result.targets.filter((t) => rows.has(t.path)).map(({ path: path23, ...t }, order) => ({
                 ...t,
                 // Filtered to rows above.
-                id: rows.get(path19),
+                id: rows.get(path23),
                 order
               })),
               quads: Object.fromEntries(
-                Object.entries(result.quads).filter(([path19]) => rows.has(path19)).map(([path19, quad]) => [rows.get(path19), quad])
+                Object.entries(result.quads).filter(([path23]) => rows.has(path23)).map(([path23, quad]) => [rows.get(path23), quad])
               )
             };
             geometryCache.set(key, geometry);
@@ -4234,12 +4784,12 @@ async function startStudio({
             0,
             state.meta.totalFrames - 1
           );
-          const selection = url2.searchParams.get("selection");
-          const row = selection ? outline?.rows.find((r) => r.id === selection) : null;
-          if (selection && !row)
+          const selection2 = url2.searchParams.get("selection");
+          const row = selection2 ? outline?.rows.find((r) => r.id === selection2) : null;
+          if (selection2 && !row)
             return json(res, 404, { error: "Element is not in this preview" });
-          const rev = state.revision, key = rev + ":" + frame + ":" + (selection ?? "");
-          let result = cache.get(key);
+          const rev = state.revision, key = rev + ":" + frame + ":" + (selection2 ?? "");
+          let result = cache2.get(key);
           if (!result) {
             if (!inflight.has(key)) {
               const pending = withNative(
@@ -4257,14 +4807,14 @@ async function startStudio({
             result = await inflight.get(key);
             if (rev !== state.revision || state.loading)
               return json(res, 409, { error: "Preview changed" });
-            if (!cache.has(key)) {
-              cache.set(key, result);
+            if (!cache2.has(key)) {
+              cache2.set(key, result);
               cacheBytes += result.bytes.length;
             }
-            while (cacheBytes > 32 * 1024 * 1024 && cache.size > 1) {
-              const first = cache.keys().next().value;
-              cacheBytes -= cache.get(first).bytes.length;
-              cache.delete(first);
+            while (cacheBytes > 32 * 1024 * 1024 && cache2.size > 1) {
+              const first = cache2.keys().next().value;
+              cacheBytes -= cache2.get(first).bytes.length;
+              cache2.delete(first);
             }
           }
           res.writeHead(200, {
@@ -4278,7 +4828,7 @@ async function startStudio({
         if (req.method === "GET" && url2.pathname === "/api/audio") {
           if (!state.meta?.audioPath || url2.searchParams.get("revision") !== state.revision)
             return json(res, 404, { error: "Audio unavailable" });
-          const bytes2 = await readFile9(state.meta.audioPath);
+          const bytes2 = await readFile10(state.meta.audioPath);
           res.writeHead(200, {
             "Content-Type": "audio/wav",
             "Cache-Control": "no-store"
@@ -4306,7 +4856,7 @@ async function startStudio({
           );
         }
         if (req.method === "POST" && url2.pathname === "/api/comments") {
-          const input = await body(req);
+          const input = await body(req, 71 * 1024 * 1024);
           if (!state.meta || input.revision !== state.revision || state.loading || dirty)
             return json(res, 409, {
               error: "Preview changed. Review the current frame before commenting."
@@ -4332,6 +4882,37 @@ async function startStudio({
             })
           );
         }
+        const attachment = url2.pathname.match(
+          /^\/api\/comments\/([a-zA-Z0-9_-]+)\/attachment$/
+        );
+        if (req.method === "GET" && attachment) {
+          const comment = (await readComments(root)).comments.find(
+            (c) => c.id === attachment[1] && c.scene === scene
+          );
+          const file2 = comment && [
+            ...comment.attachments ?? [],
+            ...comment.replies.flatMap((r) => r.attachments ?? [])
+          ].find((f) => f.path === url2.searchParams.get("path"));
+          if (!file2) return json(res, 404, { error: "Attachment not found" });
+          const filename2 = await attachmentPath(root, file2);
+          if (url2.searchParams.get("preview") === "1") {
+            const bytes2 = await attachmentThumbnail(filename2);
+            res.writeHead(200, {
+              "Content-Type": "image/jpeg",
+              "Cache-Control": "private, max-age=60"
+            });
+            return res.end(bytes2);
+          }
+          res.writeHead(200, {
+            "Content-Type": "application/octet-stream",
+            "Content-Disposition": `attachment; filename*=UTF-8''${encodeURIComponent(file2.name)}`,
+            "X-Content-Type-Options": "nosniff"
+          });
+          const stream = fs7.createReadStream(filename2);
+          res.once("close", () => stream.destroy());
+          stream.on("error", () => res.destroy()).pipe(res);
+          return;
+        }
         const thread = url2.pathname.match(
           /^\/api\/comments\/([a-zA-Z0-9_-]+)\/(reply|resolve|reopen|range|react)$/
         );
@@ -4365,6 +4946,7 @@ async function startStudio({
                 (await body(req)).emoji
               )
             );
+          const replyInput = await body(req, 71 * 1024 * 1024);
           return json(
             res,
             200,
@@ -4372,7 +4954,8 @@ async function startStudio({
               root,
               thread[1],
               thread[2],
-              (await body(req)).text
+              replyInput.text,
+              replyInput.attachments
             )
           );
         }
@@ -4422,22 +5005,22 @@ async function startStudio({
             if (!state.meta) throw new Error("Load a scene before exporting");
             const settings2 = validateExportSettings(input, state.meta);
             const format2 = exportFormats[settings2.format];
-            const filename2 = input.filename ?? `${path17.basename(scene, ".tsx")}-${Date.now()}.${format2.extension}`;
+            const filename2 = input.filename ?? `${path21.basename(scene, ".tsx")}-${Date.now()}.${format2.extension}`;
             if (typeof filename2 !== "string" || !/^[\w .-]+$/.test(filename2) || !filename2.toLowerCase().endsWith(`.${format2.extension}`) || filename2.startsWith("."))
               throw new Error(`Use a filename ending in .${format2.extension}`);
-            const folder = path17.join(root, "exports");
-            await fs6.promises.mkdir(folder, { recursive: true });
-            const canonicalFolder = await realpath(folder);
-            if (path17.relative(root, canonicalFolder).startsWith(".."))
+            const folder = path21.join(root, "exports");
+            await fs7.promises.mkdir(folder, { recursive: true });
+            const canonicalFolder = await realpath3(folder);
+            if (path21.relative(root, canonicalFolder).startsWith(".."))
               throw new Error("Export folder must stay inside the project");
-            const destination = path17.join(canonicalFolder, filename2);
+            const destination = path21.join(canonicalFolder, filename2);
             if (closed || project !== snapshot || state.loading || editing || dirty)
               throw Object.assign(
                 new Error("The scene changed before export. Try again."),
                 { status: 409 }
               );
             const job = state.export = {
-              id: randomUUID6(),
+              id: randomUUID9(),
               status: "rendering",
               phase: "preparing",
               filename: filename2,
@@ -4484,7 +5067,7 @@ async function startStudio({
           }
         }
         if (req.method === "GET" && url2.pathname === "/api/export/download" && state.export?.status === "complete" && (!url2.searchParams.has("id") || url2.searchParams.get("id") === state.export.id)) {
-          const bytes2 = await readFile9(state.export.path);
+          const bytes2 = await readFile10(state.export.path);
           res.writeHead(200, {
             "Content-Type": state.export.filename.toLowerCase().endsWith(".webm") ? "video/webm" : state.export.filename.toLowerCase().endsWith(".mov") ? "video/quicktime" : "video/mp4",
             "Content-Disposition": `attachment; filename="${state.export.filename}"`
@@ -4510,7 +5093,7 @@ async function startStudio({
         file
       ))
         return json(res, 404, { error: "Not found" });
-      const types = {
+      const types2 = {
         ".html": "text/html",
         ".wasm": "application/wasm",
         ".js": "text/javascript",
@@ -4518,13 +5101,13 @@ async function startStudio({
         ".woff2": "font/woff2",
         ".svg": "image/svg+xml"
       };
-      const bytes = await readFile9(path17.join(studioRoot, file));
+      const bytes = await readFile10(path21.join(studioRoot, file));
       res.setHeader(
         "Content-Security-Policy",
         "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' blob: data:; media-src 'self' blob:; connect-src 'self' blob:; font-src 'self'; frame-ancestors 'none'"
       );
       res.writeHead(200, {
-        "Content-Type": types[path17.extname(file)],
+        "Content-Type": types2[path21.extname(file)],
         "Cache-Control": "no-cache"
       });
       res.end(bytes);
@@ -4651,16 +5234,16 @@ Ctrl+C stops the server and renderer.`
   );
   openBrowser(url);
   try {
-    watcher = fs6.watch(root, { recursive: true }, async (event, filename2) => {
+    watcher = fs7.watch(root, { recursive: true }, async (event, filename2) => {
       const name = String(filename2 ?? "");
       if (/(^|[/\\])\.osmo-edit-/.test(name)) return;
       if (name === "storyboard.canvas.json" || name.startsWith("storyboard.canvas.json."))
         return;
       if (/(^|[/\\])(node_modules|\.git|\.osmo|exports)([/\\]|$)/.test(name))
         return;
-      if (name.startsWith("resources/") && !dependencies.includes(path17.join(root, name)))
+      if ((name.startsWith("resources/") || name === "assets" || name.startsWith("assets/")) && !dependencies.includes(path21.join(root, name)))
         return;
-      const file = path17.join(root, name), before = watchedStamps.get(file);
+      const file = path21.join(root, name), before = watchedStamps.get(file);
       const next = await fingerprint([file]);
       watchedStamps.set(file, next);
       if (closed || editing) return;
@@ -4685,6 +5268,10 @@ var studioStamp, studioDigest;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
+    init_attachment_thumbnail();
+    init_local_attachment_picker();
+    init_asset_import();
+    init_comment_attachments();
     init_export_settings();
     init_storyboard2();
     init_timeline_editor();
@@ -4702,7 +5289,7 @@ var init_server = __esm({
 // src/studio-cli.ts
 init_check();
 import { spawnSync as spawnSync4 } from "node:child_process";
-import path18 from "node:path";
+import path22 from "node:path";
 import { parseArgs } from "node:util";
 
 // src/cloud.ts
@@ -4879,8 +5466,8 @@ async function withCredentials(origin, action) {
   }
   try {
     try {
-      const stat2 = await lstat(file);
-      if (!stat2.isFile()) throw new Error("Not a regular file");
+      const stat4 = await lstat(file);
+      if (!stat4.isFile()) throw new Error("Not a regular file");
       await chmod(file, 384);
       state = JSON.parse(await readFile(file, "utf8"));
       if (state.version !== 1 || state.origin !== origin || state.credentials && !validCredentials(state.credentials) || state.pending && (!validClient(state.pending.client) || typeof state.pending.sessionId !== "string" || typeof state.pending.deviceCode !== "string" || typeof state.pending.code !== "string" || !Number.isFinite(state.pending.expiresAt) || !Number.isFinite(state.pending.nextPollAt) || !Number.isFinite(state.pending.interval) || state.pending.interval < 5 || !validApprovalUrl(state.pending.url, origin)))
@@ -5417,7 +6004,7 @@ function inspectScene(text, filename2, meta, definitions = {}) {
     );
     if (parent === null && type === "Group") props.start = 0;
     const id = typeof props.id === "string" ? `source:${props.id}` : `node-${rows.length}`, local = new Map(scope);
-    const ownKnobs = type === "Group" && props.knobs instanceof Reference ? knobs.get(props.knobs.set) : null;
+    const ownKnobs = ["Group", "Scene"].includes(type) && props.knobs instanceof Reference ? knobs.get(props.knobs.set) : null;
     if (ownKnobs)
       local.set(
         props.knobs.set,
@@ -6581,22 +7168,22 @@ init_comments();
 
 // src/init.ts
 import {
-  mkdir as mkdir5,
-  readFile as readFile6,
-  writeFile as writeFile5,
+  mkdir as mkdir6,
+  readFile as readFile7,
+  writeFile as writeFile6,
   copyFile,
   cp as cp2,
   access as access2,
   mkdtemp,
-  rm as rm5
+  rm as rm6
 } from "node:fs/promises";
-import path10 from "node:path";
+import path12 from "node:path";
 
 // src/authoring.ts
 init_runtime();
-import { readFile as readFile4, writeFile as writeFile3, rm as rm4 } from "node:fs/promises";
+import { readFile as readFile5, writeFile as writeFile4, rm as rm5 } from "node:fs/promises";
 import { createHash as createHash3 } from "node:crypto";
-import path8 from "node:path";
+import path10 from "node:path";
 var begin = "<!-- osmo:begin -->";
 var end = "<!-- osmo:end -->";
 var legacyPointer = "For Osmo animation tasks, read osmo.md before editing. Use osmo studio check, and read open Studio comments.";
@@ -6661,9 +7248,13 @@ Read relevant declarations in node_modules/@osmo/scene/dist/ (JSDoc explains usa
 - Use explicit JSX, literal values/arrays/objects, and const defineMotion or defineKnobs declarations. Bind tracks/knobs directly to compatible props.
 - No arbitrary expressions, loops, callbacks, spreads, import aliases, custom components, helper calls or computed variables. Only blur({...}) and grain({...}) effect calls are allowed in JSX; pass an explicit object, even for defaults.
 - Shader.src must be a static relative local .wgsl path. Put complete uniform values inline; numeric uniforms can use motion/knob tracks. defineEffect remains unsupported.
-- Keyframe at values are increasing local seconds (scene unless inside a timed clip); easing belongs to the arriving key. Add a key at 0 to define a continuous track's starting value. Tracks do not loop automatically.
+- Keyframe at values are increasing local seconds (scene unless inside a timed clip); easing belongs to the arriving key. Custom easing uses "cubic-bezier(x1,y1,x2,y2)" with x control points in 0..1; use curves between key poses instead of sampling every frame. Add a key at 0 to define a continuous track's starting value. Tracks do not loop automatically.
 - Group knobs can drive many descendant props; Group.values accepts motion tracks.
+- Scene also accepts knobs/values. Imported Scene instances accept values to override declared controls; forward parent refs explicitly. Each instance is independent.
+- Asset knobs: { type: "asset", kind: "image" | "video" | "audio" | "font" | "model", default: "./local-file" }. Bind to matching src/font. Assets are static; paths retain the file that declared/supplied them across nested bindings. Model files are GLB; surfaces are not auto-remapped.
+- Scale is one number applied equally to both axes; animate width/height to change a shape\u2019s proportions. Two-value scale arrays are not supported.
 - Units: pixels, degrees, seconds; +z toward viewer. Asset/font paths are relative to their declaring file.
+- Text.animate animates a whole string by character, word, or wrapped line: {unit:"character",stagger:0.05,duration:0.4,easing:"easeOut",from:{opacity:0,position:[0,20]},to:{opacity:1,position:[0,0]}}. Per-unit properties: position, z, rotation, uniform scale, origin, opacity, color, blur. Use keyframes instead of from/to/duration for multiple stages. Keep font/layout properties on Text. Do not create separate letter labels; animate cannot combine with path.
 - Text.path handles the complete string; no width/align/lineHeight or line breaks. SVG geometry is static; progress and ellipse radii can animate.
 - Path draws SVG d in local pixels; use scale to resize. d accepts a literal or a defineMotion string track for baked geometry (discrete switches, not SVG interpolation). Transforms, stroke width and effects can animate. Use fill="transparent" for lines.
 
@@ -6676,14 +7267,14 @@ ${end}
 `;
 async function optional(file) {
   try {
-    return await readFile4(file, "utf8");
+    return await readFile5(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return "";
     throw error;
   }
 }
 async function writeAuthoringGuide(root) {
-  const file = path8.join(root, "AGENTS.md");
+  const file = path10.join(root, "AGENTS.md");
   const original = await optional(file);
   const hasBegin = original.includes(begin), hasEnd = original.includes(end);
   if (hasBegin !== hasEnd || hasBegin && original.indexOf(end) < original.indexOf(begin))
@@ -6697,10 +7288,10 @@ async function writeAuthoringGuide(root) {
     const rest = original.split("\n").filter((line) => line !== legacyPointer).join("\n");
     text = rest + (rest && !rest.endsWith("\n\n") ? rest.endsWith("\n") ? "\n" : "\n\n" : "") + authoringGuide;
   }
-  if (text !== original) await writeFile3(file, text);
-  const legacy = await optional(path8.join(root, "osmo.md"));
+  if (text !== original) await writeFile4(file, text);
+  const legacy = await optional(path10.join(root, "osmo.md"));
   if (legacy && createHash3("sha256").update(legacy).digest("hex") === legacyGuideHash)
-    await rm4(path8.join(root, "osmo.md"));
+    await rm5(path10.join(root, "osmo.md"));
   else if (legacy)
     console.log(
       "Existing osmo.md was preserved because it differs from the original generated guide. Osmo instructions now live in AGENTS.md."
@@ -6712,38 +7303,38 @@ import os2 from "node:os";
 
 // src/starter.ts
 init_runtime();
-import { access, mkdir as mkdir4, readFile as readFile5, readdir as readdir2, writeFile as writeFile4, cp } from "node:fs/promises";
-import path9 from "node:path";
-var template = path9.join(packageRoot, "src/starter/");
+import { access, mkdir as mkdir5, readFile as readFile6, readdir as readdir2, writeFile as writeFile5, cp } from "node:fs/promises";
+import path11 from "node:path";
+var template = path11.join(packageRoot, "src/starter/");
 async function writeStarter(root) {
-  const scene = path9.join(root, "scene.tsx");
+  const scene = path11.join(root, "scene.tsx");
   try {
     await access(scene);
     return;
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  await mkdir4(path9.join(root, "animations"), { recursive: true });
+  await mkdir5(path11.join(root, "animations"), { recursive: true });
   let folder = "osmo";
   for (let suffix = 1; ; suffix++) {
     try {
-      await mkdir4(path9.join(root, "animations", folder));
+      await mkdir5(path11.join(root, "animations", folder));
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       folder = `osmo-${suffix}`;
     }
   }
-  for (const file of await readdir2(path9.join(template, "animations/osmo"))) {
-    await cp(path9.join(template, "animations/osmo", file), path9.join(root, "animations", folder, file), {
+  for (const file of await readdir2(path11.join(template, "animations/osmo"))) {
+    await cp(path11.join(template, "animations/osmo", file), path11.join(root, "animations", folder, file), {
       recursive: true,
       force: false,
       errorOnExist: true
     });
   }
-  const source = (await readFile5(path9.join(template, "scene.tsx"), "utf8")).replaceAll("./animations/osmo/", `./animations/${folder}/`);
+  const source = (await readFile6(path11.join(template, "scene.tsx"), "utf8")).replaceAll("./animations/osmo/", `./animations/${folder}/`);
   try {
-    await writeFile4(scene, source, {
+    await writeFile5(scene, source, {
       flag: "wx"
     });
   } catch (error) {
@@ -6764,7 +7355,7 @@ async function exists(p) {
 }
 async function create(p, value) {
   try {
-    await writeFile5(p, value, { flag: "wx" });
+    await writeFile6(p, value, { flag: "wx" });
     return true;
   } catch (e) {
     if (e.code !== "EEXIST") throw e;
@@ -6773,7 +7364,7 @@ async function create(p, value) {
 }
 async function init(root = process.cwd()) {
   nativeBinary();
-  const gitProbe = await mkdtemp(path10.join(os2.tmpdir(), "osmo-git-check-"));
+  const gitProbe = await mkdtemp(path12.join(os2.tmpdir(), "osmo-git-check-"));
   try {
     const result = spawnSync3(
       "git",
@@ -6785,7 +7376,7 @@ async function init(root = process.cwd()) {
         "Osmo projects require Git with SHA-256 support (Git 2.29+). Install or update Git, then retry osmo studio init. Sharing an existing MP4 with osmo share does not require Git."
       );
   } finally {
-    await rm5(gitProbe, { recursive: true, force: true });
+    await rm6(gitProbe, { recursive: true, force: true });
   }
   for (const [name, variable] of [
     ["ffmpeg", "OSMO_FFMPEG"],
@@ -6810,15 +7401,15 @@ async function init(root = process.cwd()) {
         );
     }
   }
-  root = path10.resolve(root);
-  await mkdir5(root, { recursive: true });
+  root = path12.resolve(root);
+  await mkdir6(root, { recursive: true });
   if (hasRepo(root) && objectFormat(root) !== "sha256")
     throw new Error(
       `${root} is already a git repository with ${objectFormat(root) ?? "unknown"} objects. Osmo projects are SHA-256 repositories: run osmo studio init in a new folder.`
     );
-  const manifestPath = path10.join(root, "package.json");
-  const manifest2 = await exists(manifestPath) ? JSON.parse(await readFile6(manifestPath, "utf8")) : {
-    name: path10.basename(root).toLowerCase().replace(/[^a-z0-9-]/g, "-") || "osmo-project",
+  const manifestPath = path12.join(root, "package.json");
+  const manifest2 = await exists(manifestPath) ? JSON.parse(await readFile7(manifestPath, "utf8")) : {
+    name: path12.basename(root).toLowerCase().replace(/[^a-z0-9-]/g, "-") || "osmo-project",
     private: true,
     type: "module"
   };
@@ -6828,58 +7419,58 @@ async function init(root = process.cwd()) {
     throw new Error(
       `Existing @osmo/scene dependency (${previous}) was preserved. Initialize a new folder for this release.`
     );
-  const configFile = path10.join(root, ".osmo/project.json");
+  const configFile = path12.join(root, ".osmo/project.json");
   if (await exists(configFile)) {
-    const config = JSON.parse(await readFile6(configFile, "utf8"));
+    const config = JSON.parse(await readFile7(configFile, "utf8"));
     assertCompatibleProject(config);
   }
-  const vendor = path10.join(root, ".osmo/vendor");
-  await mkdir5(vendor, { recursive: true });
-  await mkdir5(path10.join(root, "assets"), { recursive: true });
-  const target = path10.join(vendor, `osmo-scene-${sceneVersion}.tgz`);
+  const vendor = path12.join(root, ".osmo/vendor");
+  await mkdir6(vendor, { recursive: true });
+  await mkdir6(path12.join(root, "assets"), { recursive: true });
+  const target = path12.join(vendor, `osmo-scene-${sceneVersion}.tgz`);
   let refreshScene = false;
-  const bundled = path10.join(
+  const bundled = path12.join(
     packageRoot,
     "vendor",
     `osmo-scene-${sceneVersion}.tgz`
   );
   if (await exists(bundled)) {
-    if (!await exists(target) || !(await readFile6(target)).equals(await readFile6(bundled))) {
+    if (!await exists(target) || !(await readFile7(target)).equals(await readFile7(bundled))) {
       await copyFile(bundled, target);
       refreshScene = true;
     }
   } else {
-    const scratch = await mkdtemp(path10.join(os2.tmpdir(), "osmo-scene-pack-"));
+    const scratch = await mkdtemp(path12.join(os2.tmpdir(), "osmo-scene-pack-"));
     try {
       await run("npm", ["run", "build"], {
-        cwd: path10.join(runtimeRoot, "packages/scene")
+        cwd: path12.join(runtimeRoot, "packages/scene")
       });
-      const sceneRoot = path10.join(runtimeRoot, "packages/scene");
+      const sceneRoot = path12.join(runtimeRoot, "packages/scene");
       const { scripts, devDependencies, ...scenePackage } = JSON.parse(
-        await readFile6(path10.join(sceneRoot, "package.json"), "utf8")
+        await readFile7(path12.join(sceneRoot, "package.json"), "utf8")
       );
-      await writeFile5(
-        path10.join(scratch, "package.json"),
+      await writeFile6(
+        path12.join(scratch, "package.json"),
         JSON.stringify({ ...scenePackage, files: ["dist"] }, null, 2)
       );
-      await cp2(path10.join(sceneRoot, "dist"), path10.join(scratch, "dist"), {
+      await cp2(path12.join(sceneRoot, "dist"), path12.join(scratch, "dist"), {
         recursive: true
       });
       await run("npm", ["pack", "--pack-destination", scratch], {
         cwd: scratch
       });
-      const packed = path10.join(scratch, `osmo-scene-${sceneVersion}.tgz`);
-      if (!await exists(target) || !(await readFile6(target)).equals(await readFile6(packed))) {
+      const packed = path12.join(scratch, `osmo-scene-${sceneVersion}.tgz`);
+      if (!await exists(target) || !(await readFile7(target)).equals(await readFile7(packed))) {
         await copyFile(packed, target);
         refreshScene = true;
       }
     } finally {
-      await rm5(scratch, { recursive: true, force: true });
+      await rm6(scratch, { recursive: true, force: true });
     }
   }
   if (!previous) {
     manifest2.dependencies = { ...manifest2.dependencies, "@osmo/scene": spec };
-    await writeFile5(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
+    await writeFile6(manifestPath, JSON.stringify(manifest2, null, 2) + "\n");
   }
   const tsconfig = JSON.stringify(
     {
@@ -6898,7 +7489,7 @@ async function init(root = process.cwd()) {
     null,
     2
   ) + "\n";
-  await create(path10.join(root, "tsconfig.json"), tsconfig);
+  await create(path12.join(root, "tsconfig.json"), tsconfig);
   await writeStarter(root);
   await create(
     configFile,
@@ -6909,8 +7500,8 @@ async function init(root = process.cwd()) {
     ) + "\n"
   );
   await writeAuthoringGuide(root);
-  const ignorePath = path10.join(root, ".gitignore");
-  const ignore = await exists(ignorePath) ? await readFile6(ignorePath, "utf8") : "";
+  const ignorePath = path12.join(root, ".gitignore");
+  const ignore = await exists(ignorePath) ? await readFile7(ignorePath, "utf8") : "";
   const rules = [
     "node_modules/",
     "exports/",
@@ -6927,7 +7518,7 @@ async function init(root = process.cwd()) {
   ];
   const missing = rules.filter((rule) => !ignore.split("\n").includes(rule));
   if (missing.length)
-    await writeFile5(
+    await writeFile6(
       ignorePath,
       ignore + (ignore && !ignore.endsWith("\n") ? "\n" : "") + missing.join("\n") + "\n"
     );
@@ -6985,7 +7576,7 @@ async function studioCommand(argv, help) {
   if (args[0] === "studio" && args[1] === "clone") {
     if (args.length !== 4)
       throw new Error("Usage: osmo studio clone PROJECT_ID folder");
-    const result = await clone(args[2], path18.resolve(args[3]));
+    const result = await clone(args[2], path22.resolve(args[3]));
     console.log(
       flags.json ? JSON.stringify(result) : `Cloned ${result.name} (${result.revisions} revision${result.revisions === 1 ? "" : "s"}) into ${args[3]}.
 Next: cd ${args[3]} && osmo studio open scene.tsx`
@@ -7101,7 +7692,7 @@ ${c.text}${c.replies.map((r) => "\n  \u21B3 " + r.text).join("")}`
           throw new Error(
             "--frame must be a non-negative integer (frame 0 is the first frame)."
           );
-        if (!flags.out || path18.extname(flags.out).toLowerCase() !== (still ? ".png" : ".mp4"))
+        if (!flags.out || path22.extname(flags.out).toLowerCase() !== (still ? ".png" : ".mp4"))
           throw new Error(
             still ? "With --frame, provide --out frame.png" : "Provide --out animation.mp4, or --frame NUMBER --out frame.png"
           );
@@ -7114,7 +7705,7 @@ ${c.text}${c.replies.map((r) => "\n  \u21B3 " + r.text).join("")}`
           nativeBinary(),
           [
             source,
-            ...still ? ["--snapshot", path18.resolve(flags.out), "--frame", flags.frame] : ["--export", path18.resolve(flags.out)],
+            ...still ? ["--snapshot", path22.resolve(flags.out), "--frame", flags.frame] : ["--export", path22.resolve(flags.out)],
             "--supersample",
             quality
           ],