@osmo.inc/cli-linux-arm64 0.1.21 → 0.1.22

package/dist/studio.js

@@ -895,6 +895,94 @@ var init_comments = __esm({
   }
 });
 
+// src/project-scenes.ts
+import fs2 from "node:fs/promises";
+import path14 from "node:path";
+import ts4 from "typescript";
+async function listProjectScenes(root) {
+  const scenes = [];
+  const errors = [];
+  const ignored = /* @__PURE__ */ new Set([
+    "node_modules",
+    "dist",
+    "build",
+    "target",
+    "coverage",
+    "references",
+    "video-references"
+  ]);
+  const relative = (file) => path14.relative(root, file).split(path14.sep).join("/");
+  async function scan(folder, depth) {
+    if (depth > 16) {
+      errors.push(`${relative(folder)}: folder nesting exceeds the scan limit`);
+      return;
+    }
+    let entries;
+    try {
+      entries = await fs2.readdir(folder, { withFileTypes: true });
+    } catch (error) {
+      errors.push(`${relative(folder) || "."}: ${error.message}`);
+      return;
+    }
+    for (const item of entries) {
+      if (item.name.startsWith(".") || ignored.has(item.name) || item.isSymbolicLink())
+        continue;
+      const file = path14.join(folder, item.name);
+      if (item.isDirectory()) {
+        await scan(file, depth + 1);
+        continue;
+      }
+      if (!item.isFile() || !item.name.endsWith(".tsx")) continue;
+      const entry = relative(file);
+      try {
+        if ((await fs2.stat(file)).size > 1024 * 1024) {
+          errors.push(`${entry}: file exceeds the 1 MB scan limit`);
+          continue;
+        }
+        const text = await fs2.readFile(file, "utf8");
+        const ast = ts4.createSourceFile(
+          entry,
+          text,
+          ts4.ScriptTarget.Latest,
+          true,
+          ts4.ScriptKind.TSX
+        );
+        let node = ast.statements.find(
+          (statement) => ts4.isExportAssignment(statement) && !statement.isExportEquals
+        )?.expression;
+        while (node && ts4.isParenthesizedExpression(node))
+          node = node.expression;
+        const head = node && (ts4.isJsxElement(node) ? node.openingElement : ts4.isJsxSelfClosingElement(node) ? node : null);
+        if (head?.tagName.getText(ast) !== "Scene") continue;
+        const scene = { path: entry };
+        for (const attribute of head.attributes.properties) {
+          if (!ts4.isJsxAttribute(attribute) || !ts4.isIdentifier(attribute.name))
+            continue;
+          const name = attribute.name.text;
+          if (!["width", "height", "duration", "fps"].includes(name)) continue;
+          const value = attribute.initializer && ts4.isJsxExpression(attribute.initializer) ? attribute.initializer.expression : attribute.initializer;
+          if (value && ts4.isNumericLiteral(value) && Number.isFinite(Number(value.text)) && Number(value.text) > 0)
+            scene[name] = Number(
+              value.text
+            );
+        }
+        scenes.push(scene);
+      } catch (error) {
+        errors.push(`${entry}: ${error.message}`);
+      }
+    }
+  }
+  await scan(root, 0);
+  scenes.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  errors.sort();
+  return { scenes, errors };
+}
+var init_project_scenes = __esm({
+  "src/project-scenes.ts"() {
+    "use strict";
+  }
+});
+
 // src/asset-response.ts
 import { pipeline } from "node:stream/promises";
 async function streamAsset(req, res, asset, contentType) {
@@ -1005,29 +1093,29 @@ var init_assets = __esm({
 });
 
 // src/asset-import.ts
-import fs2 from "node:fs/promises";
-import path14 from "node:path";
+import fs3 from "node:fs/promises";
+import path15 from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 async function importProjectAsset(root, stream, name, kind, limit = Infinity) {
   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 = path14.extname(name).slice(1).toLowerCase();
+  const extension = path15.extname(name).slice(1).toLowerCase();
   if (!assetExtensions[kind].includes(extension))
     throw new Error(
       `Expected a ${kind} file (${assetExtensions[kind].join(", ")})`
     );
-  const folder = path14.join(root, "assets");
-  await fs2.mkdir(folder).catch((error) => {
+  const folder = path15.join(root, "assets");
+  await fs3.mkdir(folder).catch((error) => {
     if (error.code !== "EEXIST") throw error;
   });
   const directory = sceneInProject(root, "assets").source;
-  const stem = path14.basename(name, path14.extname(name)).normalize("NFKC").replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "asset";
+  const stem = path15.basename(name, path15.extname(name)).normalize("NFKC").replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "asset";
   const filename2 = `${stem}-${randomUUID5()}.${extension}`;
-  const target = path14.join(directory, filename2);
-  const temp = path14.join(directory, `.${filename2}.upload`);
-  const file = await fs2.open(temp, "wx", 384);
+  const target = path15.join(directory, filename2);
+  const temp = path15.join(directory, `.${filename2}.upload`);
+  const file = await fs3.open(temp, "wx", 384);
   let size = 0;
   try {
     for await (const chunk of stream) {
@@ -1039,11 +1127,11 @@ async function importProjectAsset(root, stream, name, kind, limit = Infinity) {
     }
     if (!size) throw new Error("Asset file is empty");
     await file.close();
-    await fs2.link(temp, target);
-    return path14.relative(await fs2.realpath(root), target).split(path14.sep).join("/");
+    await fs3.link(temp, target);
+    return path15.relative(await fs3.realpath(root), target).split(path15.sep).join("/");
   } finally {
     await file.close();
-    await fs2.rm(temp, { force: true });
+    await fs3.rm(temp, { force: true });
   }
 }
 var init_asset_import = __esm({
@@ -1271,49 +1359,49 @@ var init_storyboard = __esm({
 });
 
 // src/storyboard.ts
-import fs3 from "node:fs/promises";
-import path15 from "node:path";
+import fs4 from "node:fs/promises";
+import path16 from "node:path";
 import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
-import ts4 from "typescript";
+import ts5 from "typescript";
 function literal(n) {
   if (!n) return void 0;
-  if (ts4.isStringLiteral(n) || ts4.isNumericLiteral(n))
-    return ts4.isNumericLiteral(n) ? Number(n.text) : n.text;
-  if (n.kind === ts4.SyntaxKind.TrueKeyword) return true;
-  if (n.kind === ts4.SyntaxKind.FalseKeyword) return false;
-  if (ts4.isPrefixUnaryExpression(n) && n.operator === ts4.SyntaxKind.MinusToken)
+  if (ts5.isStringLiteral(n) || ts5.isNumericLiteral(n))
+    return ts5.isNumericLiteral(n) ? Number(n.text) : n.text;
+  if (n.kind === ts5.SyntaxKind.TrueKeyword) return true;
+  if (n.kind === ts5.SyntaxKind.FalseKeyword) return false;
+  if (ts5.isPrefixUnaryExpression(n) && n.operator === ts5.SyntaxKind.MinusToken)
     return -literal(n.operand);
-  if (ts4.isArrayLiteralExpression(n)) return n.elements.map(literal);
-  if (ts4.isObjectLiteralExpression(n))
+  if (ts5.isArrayLiteralExpression(n)) return n.elements.map(literal);
+  if (ts5.isObjectLiteralExpression(n))
     return Object.fromEntries(
-      n.properties.filter(ts4.isPropertyAssignment).map((p) => [p.name.text, literal(p.initializer)])
+      n.properties.filter(ts5.isPropertyAssignment).map((p) => [p.name.text, literal(p.initializer)])
     );
 }
 async function groupInfo(source, relative) {
-  const text = await fs3.readFile(source, "utf8"), ast = ts4.createSourceFile(
+  const text = await fs4.readFile(source, "utf8"), ast = ts5.createSourceFile(
     source,
     text,
-    ts4.ScriptTarget.Latest,
+    ts5.ScriptTarget.Latest,
     true,
-    ts4.ScriptKind.TSX
+    ts5.ScriptKind.TSX
   );
-  let root = ast.statements.find(ts4.isExportAssignment)?.expression;
-  while (root && ts4.isParenthesizedExpression(root)) root = root.expression;
-  const opening3 = root && (ts4.isJsxElement(root) ? root.openingElement : ts4.isJsxSelfClosingElement(root) ? root : null);
+  let root = ast.statements.find(ts5.isExportAssignment)?.expression;
+  while (root && ts5.isParenthesizedExpression(root)) root = root.expression;
+  const opening3 = root && (ts5.isJsxElement(root) ? root.openingElement : ts5.isJsxSelfClosingElement(root) ? root : null);
   if (opening3?.tagName.getText(ast) !== "Group") return null;
   const attrs = new Map(
-    opening3.attributes.properties.filter(ts4.isJsxAttribute).map((p) => [
+    opening3.attributes.properties.filter(ts5.isJsxAttribute).map((p) => [
       // A namespaced name (a:b) reads as undefined.
       p.name.text,
-      p.initializer && (ts4.isJsxExpression(p.initializer) ? p.initializer.expression : p.initializer)
+      p.initializer && (ts5.isJsxExpression(p.initializer) ? p.initializer.expression : p.initializer)
     ])
   );
   const knobName = attrs.get("knobs")?.getText(ast);
   let knobs = {};
   for (const statement of ast.statements)
-    if (ts4.isVariableStatement(statement))
+    if (ts5.isVariableStatement(statement))
       for (const d of statement.declarationList.declarations) {
-        if (d.name.getText(ast) === knobName && d.initializer && ts4.isCallExpression(d.initializer) && d.initializer.expression.getText(ast) === "defineKnobs")
+        if (d.name.getText(ast) === knobName && d.initializer && ts5.isCallExpression(d.initializer) && d.initializer.expression.getText(ast) === "defineKnobs")
           knobs = literal(d.initializer.arguments[0]) ?? {};
       }
   const defaults = literal(attrs.get("values")) ?? {};
@@ -1325,7 +1413,7 @@ async function groupInfo(source, relative) {
   };
 }
 function createStoryboard(root) {
-  const filename2 = path15.join(root, "storyboard.canvas.json"), cache2 = path15.join(root, ".osmo/cache/storyboard");
+  const filename2 = path16.join(root, "storyboard.canvas.json"), cache2 = path16.join(root, ".osmo/cache/storyboard");
   let queue = Promise.resolve(), undo = [], redo = [], knownRevision, activeRenderer, closed = false;
   const serial = (fn) => {
     const result = queue.then(fn);
@@ -1336,7 +1424,7 @@ function createStoryboard(root) {
   async function read() {
     let document;
     try {
-      document = validateBoard(JSON.parse(await fs3.readFile(filename2, "utf8")));
+      document = validateBoard(JSON.parse(await fs4.readFile(filename2, "utf8")));
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
       document = structuredClone(empty);
@@ -1353,17 +1441,17 @@ function createStoryboard(root) {
     const result = [];
     async function scan(dir, depth = 0) {
       if (depth > 8 || result.length >= 100) return;
-      for (const e of await fs3.readdir(dir, { withFileTypes: true })) {
+      for (const e of await fs4.readdir(dir, { withFileTypes: true })) {
         if (e.name.startsWith(".") || ["node_modules", "exports", "dist", "target", "assets"].includes(
           e.name
         ))
           continue;
-        const absolute = path15.join(dir, e.name);
+        const absolute = path16.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,
-            path15.relative(root, absolute).split(path15.sep).join("/")
+            path16.relative(root, absolute).split(path16.sep).join("/")
           );
           if (info2) result.push(info2);
         }
@@ -1397,10 +1485,10 @@ function createStoryboard(root) {
   async function write(document) {
     const temp = `${filename2}.${randomUUID6()}.tmp`;
     try {
-      await fs3.writeFile(temp, JSON.stringify(document, null, 2) + "\n");
-      await fs3.rename(temp, filename2);
+      await fs4.writeFile(temp, JSON.stringify(document, null, 2) + "\n");
+      await fs4.rename(temp, filename2);
     } finally {
-      await fs3.rm(temp, { force: true });
+      await fs4.rm(temp, { force: true });
     }
     knownRevision = hash(JSON.stringify(document));
   }
@@ -1452,8 +1540,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 fs3.mkdir(cache2, { recursive: true });
-      const name = `${randomUUID6()}.mp4`, destination = path15.join(cache2, name);
+      await fs4.mkdir(cache2, { recursive: true });
+      const name = `${randomUUID6()}.mp4`, destination = path16.join(cache2, name);
       const renderer = new Renderer({
         preview: {
           width: card.width,
@@ -1469,7 +1557,7 @@ function createStoryboard(root) {
         await renderer.request("export", { destination, supersample: 1 });
         return { name, revision: current.revision };
       } catch (error) {
-        await fs3.rm(destination, { force: true });
+        await fs4.rm(destination, { force: true });
         throw error;
       } finally {
         renderer.close();
@@ -1479,7 +1567,7 @@ function createStoryboard(root) {
     video: async (name) => {
       if (!/^[0-9a-f-]{36}\.mp4$/.test(name))
         throw new Error("Invalid preview");
-      return fs3.readFile(path15.join(cache2, name));
+      return fs4.readFile(path16.join(cache2, name));
     },
     close() {
       closed = true;
@@ -1503,10 +1591,10 @@ var init_storyboard2 = __esm({
 // src/asset-metadata.ts
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify4 } from "node:util";
-import path16 from "node:path";
+import path17 from "node:path";
 async function inspectAsset(file, size) {
   const metadata = { size };
-  const extension = path16.extname(file).slice(1).toLowerCase();
+  const extension = path17.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);
@@ -1566,9 +1654,9 @@ var init_asset_metadata = __esm({
 
 // src/video-normalization.ts
 import { execFile as execFile5 } from "node:child_process";
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import os3 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 import { promisify as promisify5 } from "node:util";
 function createVideoNormalizer() {
   let directory;
@@ -1590,8 +1678,8 @@ function createVideoNormalizer() {
     const task = remuxQueue.then(async () => {
       if (closed) throw new Error("Video storage is closed");
       if (cache2.has(identity2)) return;
-      directory ??= await fs4.mkdtemp(path17.join(os3.tmpdir(), "osmo-video-"));
-      const file = path17.join(directory, `${sequence++}.mp4`);
+      directory ??= await fs5.mkdtemp(path18.join(os3.tmpdir(), "osmo-video-"));
+      const file = path18.join(directory, `${sequence++}.mp4`);
       try {
         await exec5(
           process.env.OSMO_FFMPEG ?? "ffmpeg",
@@ -1617,7 +1705,7 @@ function createVideoNormalizer() {
           ],
           { timeout: 6e5, maxBuffer: 1024 * 1024 }
         );
-        const size = (await fs4.stat(file)).size;
+        const size = (await fs5.stat(file)).size;
         if (!size) throw new Error("FFmpeg produced an empty playback copy");
         await files(async () => {
           cache2.set(identity2, { file, size });
@@ -1626,12 +1714,12 @@ function createVideoNormalizer() {
             const [key, copy] = cache2.entries().next().value;
             cache2.delete(key);
             bytes -= copy.size;
-            await fs4.rm(copy.file, { force: true });
+            await fs5.rm(copy.file, { force: true });
           }
         });
       } catch (cause) {
         cache2.delete(identity2);
-        await fs4.rm(file, { force: true });
+        await fs5.rm(file, { force: true });
         const error = cause;
         const detail = error.code === "ENOENT" ? "FFmpeg is not installed or cannot be found" : error.killed ? "FFmpeg exceeded the 10-minute preparation timeout" : error.stderr?.trim() || error.message || "Unknown FFmpeg error";
         throw new Error(
@@ -1655,7 +1743,7 @@ function createVideoNormalizer() {
         if (!cached) return null;
         cache2.delete(identity2);
         cache2.set(identity2, cached);
-        return { handle: await fs4.open(cached.file, "r"), size: cached.size };
+        return { handle: await fs5.open(cached.file, "r"), size: cached.size };
       });
       if (opened) return opened;
       await prepare(source, identity2);
@@ -1673,7 +1761,7 @@ function createVideoNormalizer() {
     closed = true;
     await remuxQueue;
     await fileQueue;
-    if (directory) await fs4.rm(directory, { recursive: true, force: true });
+    if (directory) await fs5.rm(directory, { recursive: true, force: true });
     cache2.clear();
   }
   return { open, read, close };
@@ -1819,17 +1907,17 @@ var init_document_assets = __esm({
 
 // ../editor/src/runtime-paths.ts
 function withRuntimePaths(root) {
-  function visit(node, path25) {
+  function visit(node, path26) {
     if (!isSceneNode(node)) return node;
-    if (node.props.hidden === true) path25 = null;
+    if (node.props.hidden === true) path26 = null;
     let index = 0;
     return {
       ...node,
-      runtimePath: path25,
+      runtimePath: path26,
       children: node.children.map((child) => {
         const hidden = isSceneNode(child) && (child.props.hidden === true || node.type === "Scene" && node.props.tracks?.[child.props.track]?.hidden === true);
-        const omitted = !isSceneNode(child) || hidden || path25 === null || node.type === "Model" || child.type === "Camera";
-        return visit(child, omitted ? null : [path25, index++].filter((p) => p !== "").join("."));
+        const omitted = !isSceneNode(child) || hidden || path26 === null || node.type === "Model" || child.type === "Camera";
+        return visit(child, omitted ? null : [path26, index++].filter((p) => p !== "").join("."));
       })
     };
   }
@@ -1842,6 +1930,43 @@ var init_runtime_paths = __esm({
   }
 });
 
+// ../editor/src/module-parse.ts
+import ts6 from "typescript";
+function parseModule(file, text) {
+  const last = holders ? held.get(file) : void 0;
+  if (last) {
+    held.delete(file);
+    heldText -= last.text.length;
+  }
+  const tree = last?.text === text ? last.tree : ts6.createSourceFile(
+    file,
+    text,
+    ts6.ScriptTarget.Latest,
+    true,
+    ts6.ScriptKind.TSX
+  );
+  if (holders) {
+    held.set(file, { text, tree });
+    heldText += text.length;
+    for (const [path26, entry] of held) {
+      if (heldText <= HELD_TEXT) break;
+      held.delete(path26);
+      heldText -= entry.text.length;
+    }
+  }
+  return tree;
+}
+var held, holders, heldText, HELD_TEXT;
+var init_module_parse = __esm({
+  "../editor/src/module-parse.ts"() {
+    "use strict";
+    held = /* @__PURE__ */ new Map();
+    holders = 0;
+    heldText = 0;
+    HELD_TEXT = 16 * 1024 * 1024;
+  }
+});
+
 // ../editor/src/source-path.ts
 function normalize(value) {
   const parts = [];
@@ -1862,24 +1987,24 @@ var init_source_path = __esm({
 });
 
 // ../editor/src/scene-document.ts
-import ts5 from "typescript";
+import ts7 from "typescript";
 function decodeJsxLiteral(raw, attribute = false) {
-  const code = ts5.transpileModule(
+  const code = ts7.transpileModule(
     attribute ? `const x=<Text value=${raw}/>;` : `const x=<Text>${raw}</Text>;`,
-    { compilerOptions: { jsx: ts5.JsxEmit.ReactJSX } }
+    { compilerOptions: { jsx: ts7.JsxEmit.ReactJSX } }
   ).outputText;
-  const ast = ts5.createSourceFile(
+  const ast = ts7.createSourceFile(
     "literal.js",
     code,
-    ts5.ScriptTarget.Latest,
+    ts7.ScriptTarget.Latest,
     true,
-    ts5.ScriptKind.JS
+    ts7.ScriptKind.JS
   );
   let result = "";
   function visit(n) {
-    if (ts5.isPropertyAssignment(n) && n.name.text === (attribute ? "value" : "children") && ts5.isStringLiteral(n.initializer))
+    if (ts7.isPropertyAssignment(n) && n.name.text === (attribute ? "value" : "children") && ts7.isStringLiteral(n.initializer))
       result = n.initializer.text;
-    ts5.forEachChild(n, visit);
+    ts7.forEachChild(n, visit);
   }
   visit(ast);
   return result;
@@ -1893,13 +2018,7 @@ function createSceneDocument(entry, files) {
     const text = files[file];
     if (typeof text !== "string")
       throw new Error(`Missing animation source: ${file}`);
-    const ast = ts5.createSourceFile(
-      file,
-      text,
-      ts5.ScriptTarget.Latest,
-      true,
-      ts5.ScriptKind.TSX
-    );
+    const ast = parseModule(file, text);
     if (ast.parseDiagnostics.length) throw new Error(`Cannot parse ${file}`);
     const imports = {}, locals = /* @__PURE__ */ new Set();
     const location = (n) => ({
@@ -1914,32 +2033,32 @@ function createSceneDocument(entry, files) {
     };
     function read(n) {
       if (!n) return true;
-      if (ts5.isParenthesizedExpression(n) || ts5.isJsxExpression(n))
+      if (ts7.isParenthesizedExpression(n) || ts7.isJsxExpression(n))
         return n.expression ? read(n.expression) : void 0;
-      if (ts5.isStringLiteral(n) || ts5.isNumericLiteral(n))
-        return ts5.isNumericLiteral(n) ? Number(n.text) : ts5.isJsxAttribute(n.parent) && n.text.includes("&") ? decodeJsxLiteral(n.getText(ast), true) : n.text;
-      if (n.kind === ts5.SyntaxKind.TrueKeyword) return true;
-      if (n.kind === ts5.SyntaxKind.FalseKeyword) return false;
-      if (n.kind === ts5.SyntaxKind.NullKeyword) return null;
-      if (ts5.isPrefixUnaryExpression(n)) {
+      if (ts7.isStringLiteral(n) || ts7.isNumericLiteral(n))
+        return ts7.isNumericLiteral(n) ? Number(n.text) : ts7.isJsxAttribute(n.parent) && n.text.includes("&") ? decodeJsxLiteral(n.getText(ast), true) : n.text;
+      if (n.kind === ts7.SyntaxKind.TrueKeyword) return true;
+      if (n.kind === ts7.SyntaxKind.FalseKeyword) return false;
+      if (n.kind === ts7.SyntaxKind.NullKeyword) return null;
+      if (ts7.isPrefixUnaryExpression(n)) {
         const v = read(n.operand);
         if (typeof v !== "number") return unsupported(n);
-        return n.operator === ts5.SyntaxKind.MinusToken ? -v : v;
+        return n.operator === ts7.SyntaxKind.MinusToken ? -v : v;
       }
-      if (ts5.isArrayLiteralExpression(n)) return n.elements.map(read);
-      if (ts5.isObjectLiteralExpression(n))
+      if (ts7.isArrayLiteralExpression(n)) return n.elements.map(read);
+      if (ts7.isObjectLiteralExpression(n))
         return Object.fromEntries(
           n.properties.map((p) => {
-            if (!ts5.isPropertyAssignment(p) || ts5.isComputedPropertyName(p.name))
+            if (!ts7.isPropertyAssignment(p) || ts7.isComputedPropertyName(p.name))
               return unsupported(p);
             return [p.name.text, read(p.initializer)];
           })
         );
-      if (ts5.isIdentifier(n) && locals.has(n.text))
+      if (ts7.isIdentifier(n) && locals.has(n.text))
         return { $ref: `${file}#${n.text}` };
-      if (ts5.isPropertyAccessExpression(n) && ts5.isIdentifier(n.expression) && locals.has(n.expression.text))
+      if (ts7.isPropertyAccessExpression(n) && ts7.isIdentifier(n.expression) && locals.has(n.expression.text))
         return { $ref: `${file}#${n.expression.text}`, name: n.name.text };
-      if (ts5.isCallExpression(n) && (["blur", "grain"].includes(n.expression.getText(ast)) || bindings[`${file}#${n.expression.getText(ast)}`]?.kind === "effect"))
+      if (ts7.isCallExpression(n) && (["blur", "grain"].includes(n.expression.getText(ast)) || bindings[`${file}#${n.expression.getText(ast)}`]?.kind === "effect"))
         return {
           $effect: bindings[`${file}#${n.expression.getText(ast)}`]?.kind === "effect" ? `${file}#${n.expression.getText(ast)}` : n.expression.getText(ast),
           values: n.arguments[0] ? read(n.arguments[0]) : {}
@@ -1948,7 +2067,7 @@ function createSceneDocument(entry, files) {
     }
     let exported;
     for (const st of ast.statements) {
-      if (ts5.isImportDeclaration(st) && st.importClause?.name)
+      if (ts7.isImportDeclaration(st) && st.importClause?.name)
         imports[st.importClause.name.text] = module(
           resolveSceneImport(
             file,
@@ -1956,10 +2075,10 @@ function createSceneDocument(entry, files) {
           ),
           [...stack, file]
         );
-      if (ts5.isVariableStatement(st))
+      if (ts7.isVariableStatement(st))
         for (const d of st.declarationList.declarations) {
           const call2 = d.initializer;
-          if (!call2 || !ts5.isCallExpression(call2) || !["defineMotion", "defineKnobs", "defineEffect"].includes(
+          if (!call2 || !ts7.isCallExpression(call2) || !["defineMotion", "defineKnobs", "defineEffect"].includes(
             call2.expression.getText(ast)
           ))
             return unsupported(d);
@@ -1971,12 +2090,12 @@ function createSceneDocument(entry, files) {
             source: location(d)
           };
         }
-      if (ts5.isExportAssignment(st)) exported = st.expression;
+      if (ts7.isExportAssignment(st)) exported = st.expression;
     }
     function jsx2(n) {
-      if (ts5.isParenthesizedExpression(n) || ts5.isJsxExpression(n))
+      if (ts7.isParenthesizedExpression(n) || ts7.isJsxExpression(n))
         return n.expression ? jsx2(n.expression) : [];
-      if (ts5.isJsxText(n)) {
+      if (ts7.isJsxText(n)) {
         if (n.text.includes("&")) return [decodeJsxLiteral(n.getText(ast))];
         const lines = n.text.replace(/\r/g, "").split("\n"), parts = [];
         lines.forEach((line2, i) => {
@@ -1987,17 +2106,17 @@ function createSceneDocument(entry, files) {
         });
         return parts.length ? [parts.join(" ")] : [];
       }
-      if (ts5.isJsxFragment(n)) return n.children.flatMap(jsx2);
-      if (!ts5.isJsxElement(n) && !ts5.isJsxSelfClosingElement(n))
+      if (ts7.isJsxFragment(n)) return n.children.flatMap(jsx2);
+      if (!ts7.isJsxElement(n) && !ts7.isJsxSelfClosingElement(n))
         return [read(n)];
-      const opening3 = ts5.isJsxElement(n) ? n.openingElement : n, tag = opening3.tagName.getText(ast);
+      const opening3 = ts7.isJsxElement(n) ? n.openingElement : n, tag = opening3.tagName.getText(ast);
       const props = Object.fromEntries(
         opening3.attributes.properties.map((a) => {
-          if (!ts5.isJsxAttribute(a)) return unsupported(a);
+          if (!ts7.isJsxAttribute(a)) return unsupported(a);
           return [a.name.text, read(a.initializer)];
         })
       );
-      const children = ts5.isJsxElement(n) ? n.children.flatMap(jsx2) : [];
+      const children = ts7.isJsxElement(n) ? n.children.flatMap(jsx2) : [];
       if ("label" in props) {
         if (tag !== "Group" && !imports[tag])
           throw new Error("label belongs to Groups only");
@@ -2138,6 +2257,7 @@ var init_scene_document = __esm({
   "../editor/src/scene-document.ts"() {
     "use strict";
     init_runtime_paths();
+    init_module_parse();
     init_source_path();
     init_metadata();
     init_types();
@@ -2374,10 +2494,10 @@ var init_document_outline = __esm({
 });
 
 // src/scene-document.ts
-import fs5 from "node:fs/promises";
-import path18 from "node:path";
+import fs6 from "node:fs/promises";
+import path19 from "node:path";
 import { createHash as createHash5 } from "node:crypto";
-import ts6 from "typescript";
+import ts8 from "typescript";
 function createDocumentLoader(root) {
   const videos = createVideoNormalizer();
   const assets = /* @__PURE__ */ new Map();
@@ -2389,16 +2509,16 @@ function createDocumentLoader(root) {
         throw new Error("Cyclic animation imports");
       if (Object.hasOwn(files, file)) return;
       const located = sceneInProject(root, file);
-      files[file] = body3 ?? inputs.get(located.source) ?? await fs5.readFile(located.source, "utf8");
-      const ast = ts6.createSourceFile(
+      files[file] = body3 ?? inputs.get(located.source) ?? await fs6.readFile(located.source, "utf8");
+      const ast = ts8.createSourceFile(
         file,
         files[file],
-        ts6.ScriptTarget.Latest,
+        ts8.ScriptTarget.Latest,
         true,
-        ts6.ScriptKind.TSX
+        ts8.ScriptKind.TSX
       );
       for (const st of ast.statements)
-        if (ts6.isImportDeclaration(st) && st.importClause?.name)
+        if (ts8.isImportDeclaration(st) && st.importClause?.name)
           await read(
             // A module specifier is a string literal.
             resolveSceneImport(
@@ -2415,7 +2535,7 @@ function createDocumentLoader(root) {
     document.assets = {};
     try {
       for (const ref of documentAssetReferences(document)) {
-        const relative = path18.posix.normalize(path18.posix.join(path18.posix.dirname(ref.file), ref.value));
+        const relative = path19.posix.normalize(path19.posix.join(path19.posix.dirname(ref.file), ref.value));
         if (document.assets[relative]) continue;
         try {
           document.assets[relative] = await registerAsset(relative, ref.kind);
@@ -2430,7 +2550,7 @@ function createDocumentLoader(root) {
     return { ...document, ...includeSources ? { sourceFiles: files } : {} };
   }
   async function registerAsset(relative, kind) {
-    const located = sceneInProject(root, relative), info = await fs5.stat(located.source);
+    const located = sceneInProject(root, relative), info = await fs6.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, {
@@ -2441,7 +2561,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 fs5.readFile(located.source, "utf8");
+      asset.code = await fs6.readFile(located.source, "utf8");
     }
     return asset;
   }
@@ -2490,7 +2610,7 @@ function createDocumentLoader(root) {
     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 fs5.stat(current.source);
+    const current = sceneInProject(root, asset.file), info = await fs6.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."),
@@ -2500,9 +2620,9 @@ function createDocumentLoader(root) {
   }
   async function openAsset(id) {
     const current = await locateAsset(id);
-    const extension = path18.extname(current.file).toLowerCase();
+    const extension = path19.extname(current.file).toLowerCase();
     const normalized = [".mp4", ".mov", ".m4v"].includes(extension);
-    const opened = normalized ? await videos.open(current.file, id) : { handle: await fs5.open(current.file, "r"), size: current.size };
+    const opened = normalized ? await videos.open(current.file, id) : { handle: await fs6.open(current.file, "r"), size: current.size };
     try {
       await locateAsset(id);
       return { ...opened, extension: normalized ? ".mp4" : extension };
@@ -2542,30 +2662,29 @@ var init_scene_document2 = __esm({
 });
 
 // src/project-resources.ts
-import fs6 from "node:fs/promises";
-import path19 from "node:path";
+import fs7 from "node:fs/promises";
+import path20 from "node:path";
 import { execFile as execFile6 } from "node:child_process";
 import { promisify as promisify6 } from "node:util";
-import ts7 from "typescript";
 async function resourceFile(root, relative) {
-  if (typeof relative !== "string" || path19.isAbsolute(relative))
+  if (typeof relative !== "string" || path20.isAbsolute(relative))
     throw new Error("Resource paths must be relative.");
-  const base = await fs6.realpath(root), file = await fs6.realpath(path19.resolve(base, relative));
-  if (!inside(path19.join(base, "resources"), file) || (await fs6.stat(file)).isDirectory())
+  const base = await fs7.realpath(root), file = await fs7.realpath(path20.resolve(base, relative));
+  if (!inside(path20.join(base, "resources"), file) || (await fs7.stat(file)).isDirectory())
     throw new Error("Resource files must stay inside resources/.");
   return file;
 }
 async function resourceFolder(root) {
-  const base = await fs6.realpath(root), folder = path19.join(base, "resources");
-  await fs6.mkdir(folder, { recursive: true });
-  if ((await fs6.lstat(folder)).isSymbolicLink())
+  const base = await fs7.realpath(root), folder = path20.join(base, "resources");
+  await fs7.mkdir(folder, { recursive: true });
+  if ((await fs7.lstat(folder)).isSymbolicLink())
     throw new Error("resources/ must be a real directory.");
   return folder;
 }
 async function listProjectResources(root) {
   let entries;
   try {
-    entries = await fs6.readdir(path19.join(root, "resources"), {
+    entries = await fs7.readdir(path20.join(root, "resources"), {
       withFileTypes: true
     });
   } catch (e) {
@@ -2577,12 +2696,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 fs6.stat(manifestFile)).size > 1024 * 1024)
+      if ((await fs7.stat(manifestFile)).size > 1024 * 1024)
         throw new Error("Manifest exceeds 1 MB");
-      const meta = JSON.parse(await fs6.readFile(manifestFile, "utf8"));
+      const meta = JSON.parse(await fs7.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[path19.extname(file).toLowerCase()];
-      if (!["shader", "image", "video", "model", "scene"].includes(kind) || kinds[path19.extname(file).toLowerCase()] !== kind)
+      const kind = meta.kind ?? (meta.category === "3d" ? "model" : meta.category) ?? kinds[path20.extname(file).toLowerCase()];
+      if (!["shader", "image", "video", "model", "scene"].includes(kind) || kinds[path20.extname(file).toLowerCase()] !== kind)
         throw new Error("Unsupported resource type");
       let effect;
       if (kind === "shader" && meta.effect) {
@@ -2600,7 +2719,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 fs6.stat(file), preview = meta.preview ? `resources/${item.name}/${meta.preview}` : ["image", "video"].includes(kind) ? entry : null;
+      const info = await fs7.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,
@@ -2615,83 +2734,34 @@ 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 fs6.stat(manifestFile)).mtimeMs}`
+        stamp: `${info.mtimeMs}:${info.size}:${(await fs7.stat(manifestFile)).mtimeMs}`
       });
     } catch (error) {
       if (error.code !== "ENOENT")
         errors.push(`${item.name}: ${error.message}`);
     }
   }
-  async function scenes(folder, depth = 0) {
-    if (depth > 16) return;
-    for (const item of await fs6.readdir(folder, { withFileTypes: true })) {
-      if (item.name.startsWith(".") || [
-        "node_modules",
-        "dist",
-        "target",
-        "references",
-        "video-references"
-      ].includes(item.name) || item.isSymbolicLink())
-        continue;
-      const file = path19.join(folder, item.name);
-      if (item.isDirectory()) {
-        await scenes(file, depth + 1);
-        continue;
-      }
-      if (!item.isFile() || !item.name.endsWith(".tsx") || (await fs6.stat(file)).size > 1024 * 1024)
-        continue;
-      const entry = path19.relative(root, file).split(path19.sep).join("/");
-      try {
-        const text = await fs6.readFile(file, "utf8"), ast = ts7.createSourceFile(
-          entry,
-          text,
-          ts7.ScriptTarget.Latest,
-          true,
-          ts7.ScriptKind.TSX
-        );
-        let node = ast.statements.find(ts7.isExportAssignment)?.expression;
-        while (node && ts7.isParenthesizedExpression(node))
-          node = node.expression;
-        const head = node && (ts7.isJsxElement(node) ? node.openingElement : ts7.isJsxSelfClosingElement(node) ? node : null);
-        if (head?.tagName.getText(ast) !== "Scene") continue;
-        const attrs = Object.fromEntries(
-          head.attributes.properties.filter(ts7.isJsxAttribute).map((a) => {
-            const value = ts7.isJsxExpression(a.initializer ?? {}) ? a.initializer.expression : a.initializer;
-            return [
-              // A namespaced name (a:b) has no text; nothing reads it.
-              a.name.text,
-              value && ts7.isNumericLiteral(value) ? Number(value.text) : void 0
-            ];
-          })
-        );
-        if (![attrs.width, attrs.height, attrs.duration].every(
-          (v) => Number.isFinite(v) && v > 0
-        ))
-          continue;
-        const existing = resources.find((r) => r.entry === entry);
-        const info = {
-          width: attrs.width,
-          height: attrs.height,
-          duration: attrs.duration,
-          fps: attrs.fps ?? 30
-        };
-        if (existing) Object.assign(existing, info);
-        else
-          resources.push({
-            id: `scene:${entry}`,
-            title: item.name === "scene.tsx" ? path19.basename(folder) : item.name.slice(0, -4),
-            kind: "scene",
-            entry,
-            ...info,
-            preview: null,
-            stamp: String((await fs6.stat(file)).mtimeMs)
-          });
-      } catch (error) {
-        errors.push(`${entry}: ${error.message}`);
-      }
+  const catalog = await listProjectScenes(root);
+  errors.push(...catalog.errors);
+  for (const scene of catalog.scenes) {
+    const { path: entry, width, height, duration, fps } = scene;
+    if (!width || !height || !duration) continue;
+    const existing = resources.find((resource) => resource.entry === entry);
+    const info = { width, height, duration, fps: fps ?? 30 };
+    if (existing) Object.assign(existing, info);
+    else {
+      const name = path20.basename(entry);
+      resources.push({
+        id: `scene:${entry}`,
+        title: name === "scene.tsx" ? path20.basename(path20.dirname(path20.join(root, entry))) : name.slice(0, -4),
+        kind: "scene",
+        entry,
+        ...info,
+        preview: null,
+        stamp: String((await fs7.stat(path20.join(root, entry))).mtimeMs)
+      });
     }
   }
-  await scenes(root);
   return { resources, errors };
 }
 async function getProjectResource(root, id) {
@@ -2703,33 +2773,33 @@ 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[path19.extname(file).toLowerCase()];
+  const file = await resourceFile(root, resource.preview), type = mime[path20.extname(file).toLowerCase()];
   if (!type) throw new Error("Unsupported preview type");
-  if ((await fs6.stat(file)).size > 12 * 1024 * 1024)
+  if ((await fs7.stat(file)).size > 12 * 1024 * 1024)
     throw new Error("Preview is too large");
-  return { bytes: await fs6.readFile(file), type };
+  return { bytes: await fs7.readFile(file), type };
 }
 async function installResourceExamples(root) {
-  const folder = await resourceFolder(root), source = path19.join(packageRoot, "src/resource-examples/");
-  for (const item of await fs6.readdir(source, { withFileTypes: true })) {
+  const folder = await resourceFolder(root), source = path20.join(packageRoot, "src/resource-examples/");
+  for (const item of await fs7.readdir(source, { withFileTypes: true })) {
     if (!item.isDirectory()) continue;
-    const destination = path19.join(folder, item.name);
+    const destination = path20.join(folder, item.name);
     try {
-      await fs6.mkdir(destination);
+      await fs7.mkdir(destination);
     } catch (e) {
       if (e.code === "EEXIST") continue;
       throw e;
     }
     try {
-      for (const file of (await fs6.readdir(path19.join(source, item.name))).sort(
+      for (const file of (await fs7.readdir(path20.join(source, item.name))).sort(
         (a, b) => Number(a === "resource.json") - Number(b === "resource.json")
       ))
-        await fs6.copyFile(
-          path19.join(source, item.name, file),
-          path19.join(destination, file)
+        await fs7.copyFile(
+          path20.join(source, item.name, file),
+          path20.join(destination, file)
         );
     } catch (error) {
-      await fs6.rm(destination, { recursive: true, force: true });
+      await fs7.rm(destination, { recursive: true, force: true });
       throw error;
     }
   }
@@ -2739,6 +2809,7 @@ var exec6, kinds, mime, inside;
 var init_project_resources = __esm({
   "src/project-resources.ts"() {
     "use strict";
+    init_project_scenes();
     init_runtime();
     exec6 = promisify6(execFile6);
     kinds = {
@@ -2765,8 +2836,8 @@ var init_project_resources = __esm({
       ".mov": "video/quicktime"
     };
     inside = (root, file) => {
-      const rel = path19.relative(root, file);
-      return rel !== ".." && !rel.startsWith(".." + path19.sep) && !path19.isAbsolute(rel);
+      const rel = path20.relative(root, file);
+      return rel !== ".." && !rel.startsWith(".." + path20.sep) && !path20.isAbsolute(rel);
     };
   }
 });
@@ -3005,6 +3076,86 @@ var init_resource_drop = __esm({
   }
 });
 
+// ../editor/src/duplicate-motion.ts
+import ts9 from "typescript";
+function duplicateMotionBindings(source) {
+  const definitions = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Set();
+  function collect(node) {
+    if (ts9.isIdentifier(node)) names.add(node.text);
+    ts9.forEachChild(node, collect);
+  }
+  collect(source);
+  for (const statement of source.statements) {
+    if (!ts9.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      const call2 = declaration.initializer;
+      if (ts9.isIdentifier(declaration.name) && call2 && ts9.isCallExpression(call2) && ts9.isIdentifier(call2.expression) && call2.expression.text === "defineMotion")
+        definitions.set(declaration.name.text, call2.getText(source));
+    }
+  }
+  const copies = /* @__PURE__ */ new Map();
+  let index = 1;
+  return {
+    copy(text) {
+      const ast = ts9.createSourceFile(
+        "copy.tsx",
+        text,
+        ts9.ScriptTarget.Latest,
+        true,
+        ts9.ScriptKind.TSX
+      );
+      const edits = [];
+      function visit(node) {
+        if (ts9.isPropertyAccessExpression(node) && ts9.isIdentifier(node.expression) && definitions.has(node.expression.text)) {
+          const original = node.expression.text;
+          let name = copies.get(original);
+          if (!name) {
+            do {
+              name = `motionCopy${index++}`;
+            } while (names.has(name));
+            names.add(name);
+            copies.set(original, name);
+          }
+          edits.push({
+            start: node.expression.getStart(ast),
+            end: node.expression.end,
+            text: name
+          });
+        }
+        ts9.forEachChild(node, visit);
+      }
+      visit(ast);
+      for (const edit of edits.sort((a, b) => b.start - a.start))
+        text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+      return text;
+    },
+    finish(text) {
+      if (!copies.size) return text;
+      const ast = ts9.createSourceFile(
+        source.fileName,
+        text,
+        ts9.ScriptTarget.Latest,
+        true,
+        ts9.ScriptKind.TSX
+      );
+      const exported = ast.statements.find(ts9.isExportAssignment);
+      if (!exported) throw new Error("Scene export no longer exists");
+      const at = exported.getStart(ast);
+      const declarations2 = [...copies].map(
+        ([original, name]) => `const ${name} = ${definitions.get(original)};
+`
+      ).join("");
+      return text.slice(0, at) + declarations2 + text.slice(at);
+    }
+  };
+}
+var init_duplicate_motion = __esm({
+  "../editor/src/duplicate-motion.ts"() {
+    "use strict";
+  }
+});
+
 // ../editor/src/property-validation.ts
 function validProperty(name, value, spec) {
   if (name === "mask") {
@@ -3168,29 +3319,29 @@ var init_timing_model = __esm({
 });
 
 // ../editor/src/timeline.ts
-import ts8 from "typescript";
+import ts10 from "typescript";
 function literal2(node) {
   const n = unwrap(node);
   if (!n) return { known: false };
-  if (ts8.isStringLiteral(n)) return { known: true, value: n.text };
-  if (ts8.isNumericLiteral(n)) return { known: true, value: Number(n.text) };
-  if (n.kind === ts8.SyntaxKind.TrueKeyword || n.kind === ts8.SyntaxKind.FalseKeyword)
-    return { known: true, value: n.kind === ts8.SyntaxKind.TrueKeyword };
-  if (ts8.isPrefixUnaryExpression(n) && [ts8.SyntaxKind.MinusToken, ts8.SyntaxKind.PlusToken].includes(n.operator)) {
+  if (ts10.isStringLiteral(n)) return { known: true, value: n.text };
+  if (ts10.isNumericLiteral(n)) return { known: true, value: Number(n.text) };
+  if (n.kind === ts10.SyntaxKind.TrueKeyword || n.kind === ts10.SyntaxKind.FalseKeyword)
+    return { known: true, value: n.kind === ts10.SyntaxKind.TrueKeyword };
+  if (ts10.isPrefixUnaryExpression(n) && [ts10.SyntaxKind.MinusToken, ts10.SyntaxKind.PlusToken].includes(n.operator)) {
     const v = literal2(n.operand);
     return typeof v.value === "number" ? {
       known: true,
-      value: v.value * (n.operator === ts8.SyntaxKind.MinusToken ? -1 : 1)
+      value: v.value * (n.operator === ts10.SyntaxKind.MinusToken ? -1 : 1)
     } : { known: false };
   }
-  if (ts8.isArrayLiteralExpression(n)) {
+  if (ts10.isArrayLiteralExpression(n)) {
     const items = n.elements.map(literal2);
     return items.every((v) => v.known) ? { known: true, value: items.map((v) => v.value) } : { known: false };
   }
-  if (ts8.isObjectLiteralExpression(n)) {
+  if (ts10.isObjectLiteralExpression(n)) {
     const entries = [];
     for (const p of n.properties) {
-      if (!ts8.isPropertyAssignment(p) || ts8.isComputedPropertyName(p.name))
+      if (!ts10.isPropertyAssignment(p) || ts10.isComputedPropertyName(p.name))
         return { known: false };
       const v = literal2(p.initializer);
       if (!v.known) return { known: false };
@@ -3201,25 +3352,25 @@ function literal2(node) {
   return { known: false };
 }
 function opening(n) {
-  return ts8.isJsxElement(n) ? n.openingElement : ts8.isJsxSelfClosingElement(n) ? n : null;
+  return ts10.isJsxElement(n) ? n.openingElement : ts10.isJsxSelfClosingElement(n) ? n : null;
 }
 function childCount(n) {
   return (n.children ?? []).reduce(
-    (count, child) => count + (ts8.isJsxFragment(child) || opening(child)?.tagName.getText() === "Fragment" ? childCount(child) : opening(child) ? 1 : 0),
+    (count, child) => count + (ts10.isJsxFragment(child) || opening(child)?.tagName.getText() === "Fragment" ? childCount(child) : opening(child) ? 1 : 0),
     0
   );
 }
 function attributes(n) {
   return new Map(
-    opening(n).attributes.properties.filter(ts8.isJsxAttribute).map((p) => [p.name.text, p])
+    opening(n).attributes.properties.filter(ts10.isJsxAttribute).map((p) => [p.name.text, p])
   );
 }
 function declarations(ast) {
   const result = {};
   for (const st of ast.statements)
-    if (ts8.isVariableStatement(st))
+    if (ts10.isVariableStatement(st))
       for (const d of st.declarationList.declarations) {
-        if (d.initializer && ts8.isCallExpression(d.initializer) && d.initializer.expression.getText(ast) === "defineKnobs")
+        if (d.initializer && ts10.isCallExpression(d.initializer) && d.initializer.expression.getText(ast) === "defineKnobs")
           result[d.name.getText(ast)] = literal2(d.initializer.arguments[0]).value ?? {};
       }
   return result;
@@ -3276,13 +3427,7 @@ function propertiesFor(type) {
   };
 }
 function describeGroup(text, filename2 = "animation.tsx") {
-  const ast = ts8.createSourceFile(
-    filename2,
-    text,
-    ts8.ScriptTarget.Latest,
-    true,
-    ts8.ScriptKind.TSX
-  ), n = unwrap(ast.statements.find(ts8.isExportAssignment)?.expression);
+  const ast = parseModule(filename2, text), n = unwrap(ast.statements.find(ts10.isExportAssignment)?.expression);
   if (!n || !opening(n) || !["Scene", "Group"].includes(opening(n).tagName.getText(ast)))
     throw new Error("Reusable file must default-export a Scene or Group");
   const attrs = attributes(n), props = Object.fromEntries(
@@ -3294,7 +3439,7 @@ function describeGroup(text, filename2 = "animation.tsx") {
   const name = unwrap(attrs.get("knobs")?.initializer)?.getText(ast);
   const valueNode = unwrap(attrs.get("values")?.initializer);
   const values = Object.fromEntries(
-    valueNode && ts8.isObjectLiteralExpression(valueNode) ? valueNode.properties.filter(ts8.isPropertyAssignment).map((p) => [
+    valueNode && ts10.isObjectLiteralExpression(valueNode) ? valueNode.properties.filter(ts10.isPropertyAssignment).map((p) => [
       p.name.text,
       {
         ...literal2(p.initializer),
@@ -3324,7 +3469,7 @@ function describeClip(n, ast, definitions, knobs) {
   const track = attrLiteral(attrs.get("track")).value;
   const schema = definition?.knobs ?? knobs[unwrap(attrs.get("knobs")?.initializer)?.getText(ast)] ?? {};
   const valueNode = unwrap(attrs.get("values")?.initializer), overrides = new Map(
-    valueNode && ts8.isObjectLiteralExpression(valueNode) ? valueNode.properties.filter(ts8.isPropertyAssignment).map((p) => [
+    valueNode && ts10.isObjectLiteralExpression(valueNode) ? valueNode.properties.filter(ts10.isPropertyAssignment).map((p) => [
       p.name.text,
       p
     ]) : []
@@ -3357,8 +3502,8 @@ function describeClip(n, ast, definitions, knobs) {
       expression: v.expression
     };
   });
-  const words2 = tag === "Text" && ts8.isJsxElement(n) ? n.children.map(
-    (c) => ts8.isJsxText(c) ? c.text : ts8.isJsxExpression(c) ? literal2(c.expression).value ?? "" : ""
+  const words2 = tag === "Text" && ts10.isJsxElement(n) ? n.children.map(
+    (c) => ts10.isJsxText(c) ? c.text : ts10.isJsxExpression(c) ? literal2(c.expression).value ?? "" : ""
   ).join("").trim().replace(/\s+/g, " ").slice(0, 64) : "";
   return {
     id: id ?? `draft:${n.getStart(ast)}`,
@@ -3383,13 +3528,7 @@ function describeClip(n, ast, definitions, knobs) {
   };
 }
 function parse(text, definitions = {}, filename2 = "scene.tsx") {
-  const ast = ts8.createSourceFile(
-    filename2,
-    text,
-    ts8.ScriptTarget.Latest,
-    true,
-    ts8.ScriptKind.TSX
-  ), root = unwrap(ast.statements.find(ts8.isExportAssignment)?.expression);
+  const ast = parseModule(filename2, text), root = unwrap(ast.statements.find(ts10.isExportAssignment)?.expression);
   if (ast.parseDiagnostics.length)
     throw new Error("Fix the TSX syntax before editing");
   if (!root || !opening(root) || opening(root).tagName.getText(ast) !== "Scene")
@@ -3409,7 +3548,7 @@ function parse(text, definitions = {}, filename2 = "scene.tsx") {
     throw new Error("Scene duration and fps must be literal numbers");
   const knobs = declarations(ast), clips = [];
   function visit(n) {
-    if (ts8.isJsxFragment(n) || opening(n)?.tagName.getText(ast) === "Fragment" && ts8.isJsxElement(n)) {
+    if (ts10.isJsxFragment(n) || opening(n)?.tagName.getText(ast) === "Fragment" && ts10.isJsxElement(n)) {
       n.children.forEach(visit);
       return;
     }
@@ -3432,7 +3571,7 @@ function parse(text, definitions = {}, filename2 = "scene.tsx") {
       throw new Error("Clips must stay inside the scene.");
     clips.push({ ...clip, ...timing });
   }
-  if (ts8.isJsxElement(root)) root.children.forEach(visit);
+  if (ts10.isJsxElement(root)) root.children.forEach(visit);
   const assigned = clips.filter((c) => c.track !== void 0);
   for (const clip of clips.filter((c) => c.track === void 0)) {
     clip.track = 0;
@@ -3497,28 +3636,28 @@ function setAttrs(text, node, values, ast) {
 }
 function copyClip(clip, ast, values, fresh) {
   let text = clip.node.getText(ast);
-  const subtree = ts8.createSourceFile(
+  const subtree = ts10.createSourceFile(
     "copy.tsx",
     text,
-    ts8.ScriptTarget.Latest,
+    ts10.ScriptTarget.Latest,
     true,
-    ts8.ScriptKind.TSX
+    ts10.ScriptKind.TSX
   ), edits = [];
   const ids = /* @__PURE__ */ new Map();
   function collect(node2) {
-    if (ts8.isJsxAttribute(node2) && node2.name.text === "id")
+    if (ts10.isJsxAttribute(node2) && node2.name.text === "id")
       ids.set(literal2(node2.initializer).value, fresh());
-    ts8.forEachChild(node2, collect);
+    ts10.forEachChild(node2, collect);
   }
   collect(subtree);
   function replace(node2) {
-    if (ts8.isJsxAttribute(node2) && node2.name.text === "id")
+    if (ts10.isJsxAttribute(node2) && node2.name.text === "id")
       edits.push({
         start: node2.getStart(subtree),
         end: node2.end,
         text: `id={${JSON.stringify(ids.get(literal2(node2.initializer).value))}}`
       });
-    if (ts8.isJsxAttribute(node2) && node2.name.text === "mask") {
+    if (ts10.isJsxAttribute(node2) && node2.name.text === "mask") {
       const raw = literal2(node2.initializer).value, mask = readMask(raw);
       if (mask && ids.has(mask.source)) {
         const value = typeof raw === "string" ? ids.get(mask.source) : { ...raw, source: ids.get(mask.source) };
@@ -3529,16 +3668,16 @@ function copyClip(clip, ast, values, fresh) {
         });
       }
     }
-    ts8.forEachChild(node2, replace);
+    ts10.forEachChild(node2, replace);
   }
   replace(subtree);
   text = patches(text, edits);
-  const copyAst = ts8.createSourceFile(
+  const copyAst = ts10.createSourceFile(
     "copy.tsx",
     text,
-    ts8.ScriptTarget.Latest,
+    ts10.ScriptTarget.Latest,
     true,
-    ts8.ScriptKind.TSX
+    ts10.ScriptKind.TSX
   ), node = copyAst.statements[0].expression;
   return {
     text: setAttrs(text, node, values, copyAst),
@@ -3567,11 +3706,11 @@ function editClipValue(text, clip, command, ast) {
     if (!validKnob(knob.schema, command.value))
       throw new Error(`Invalid ${command.name}`);
     const attr = clip.attrs.get("values"), object = unwrap(attr?.initializer), rendered = JSON.stringify(command.value);
-    if (object && !ts8.isObjectLiteralExpression(object))
+    if (object && !ts10.isObjectLiteralExpression(object))
       throw new Error("Edit the values binding in source.");
     if (object) {
       const prop = object.properties.find(
-        (p) => ts8.isPropertyAssignment(p) && p.name.text === command.name
+        (p) => ts10.isPropertyAssignment(p) && p.name.text === command.name
       );
       if (prop)
         text = patches(text, [
@@ -3603,17 +3742,17 @@ function editClipValue(text, clip, command, ast) {
 }
 function editGroupSource(text, sourceStart, command, filename2 = "scene.tsx") {
   const changes = groupChanges(command);
-  const ast = ts8.createSourceFile(
+  const ast = ts10.createSourceFile(
     filename2,
     text,
-    ts8.ScriptTarget.Latest,
+    ts10.ScriptTarget.Latest,
     true,
-    ts8.ScriptKind.TSX
+    ts10.ScriptKind.TSX
   );
   let target;
   function visit(node) {
     if (opening(node)?.getStart(ast) === sourceStart) target = node;
-    else ts8.forEachChild(node, visit);
+    else ts10.forEachChild(node, visit);
   }
   visit(ast);
   if (!target) throw new Error("Group source no longer exists");
@@ -3638,7 +3777,7 @@ function applyTimelineCommand(text, command, {
       const v = literal2(attributes(n).get("id")?.initializer).value;
       if (v) ids.add(v);
     }
-    ts8.forEachChild(n, collect);
+    ts10.forEachChild(n, collect);
   }
   collect(model.ast);
   const fresh = () => {
@@ -3688,6 +3827,7 @@ function applyTimelineCommand(text, command, {
     if (duplicate)
       next.tracks[command.track + 1] = { ...model.tracks[command.track] };
     const edits = [];
+    const motions = duplicateMotionBindings(model.ast);
     for (const clip2 of model.clips) {
       const updated = next.clips.find((c) => c.id === clip2.id);
       if (!updated)
@@ -3714,12 +3854,13 @@ function applyTimelineCommand(text, command, {
         edits.push({
           start: clip2.node.end,
           end: clip2.node.end,
-          text: "\n  " + copy.text
+          text: "\n  " + motions.copy(copy.text)
         });
       }
     }
     text = patches(text, edits);
     text = setAttrs(text, model.root, { tracks: next.tracks }, model.ast);
+    text = motions.finish(text);
     return { text, selection: null, idMap: Object.fromEntries(idMap) };
   }
   if (command.type === "move" || command.type === "trim") {
@@ -3788,10 +3929,13 @@ function applyTimelineCommand(text, command, {
     }
     if (track >= 100) throw new Error("Maximum 100 tracks");
     const copy = copyClip(clip, model.ast, { start, track }, fresh);
+    const motions = duplicateMotionBindings(model.ast);
+    copy.text = motions.copy(copy.text);
     id = copy.id;
     text = patches(text, [
       { start: clip.node.end, end: clip.node.end, text: "\n  " + copy.text }
     ]);
+    text = motions.finish(text);
   } else if (command.type === "property") {
     text = editClipValue(text, clip, command, model.ast);
   } else if (command.type === "knob") {
@@ -3816,7 +3960,7 @@ function applyTimelineCommand(text, command, {
     ))
       track++;
     if (track >= 100) throw new Error("Maximum 100 tracks");
-    const imports = model.ast.statements.filter(ts8.isImportDeclaration), existing = imports.find(
+    const imports = model.ast.statements.filter(ts10.isImportDeclaration), existing = imports.find(
       (st) => st.importClause?.name && (st.moduleSpecifier.text === importPath || definition.source && definitions[st.importClause.name.text]?.source === definition.source)
     );
     let tag = existing?.importClause.name.text;
@@ -3836,7 +3980,7 @@ function applyTimelineCommand(text, command, {
       model = parse(text, definitions, filename2);
     }
     const root = model.root;
-    if (ts8.isJsxSelfClosingElement(root))
+    if (ts10.isJsxSelfClosingElement(root))
       text = patches(text, [
         {
           start: root.end - 2,
@@ -3875,18 +4019,20 @@ var unwrap, attrLiteral, propertySpecs, pick, transformNames, numberProp, mediaS
 var init_timeline = __esm({
   "../editor/src/timeline.ts"() {
     "use strict";
+    init_duplicate_motion();
     init_mask();
     init_property_validation();
     init_clip();
     init_metadata();
     init_labels();
+    init_module_parse();
     init_track_model();
     init_group_model();
     init_timing_model();
     init_clip_timing();
     init_clip_timing();
     unwrap = (n) => {
-      while (n && (ts8.isParenthesizedExpression(n) || ts8.isJsxExpression(n)))
+      while (n && (ts10.isParenthesizedExpression(n) || ts10.isJsxExpression(n)))
         n = n.expression;
       return n;
     };
@@ -3967,20 +4113,20 @@ var init_timeline = __esm({
 });
 
 // ../editor/src/resource-source.ts
-import ts9 from "typescript";
+import ts11 from "typescript";
 function addImports(text, names, declaration = "") {
-  const ast = ts9.createSourceFile(
+  const ast = ts11.createSourceFile(
     "scene.tsx",
     text,
-    ts9.ScriptTarget.Latest,
+    ts11.ScriptTarget.Latest,
     true,
-    ts9.ScriptKind.TSX
+    ts11.ScriptKind.TSX
   );
   const existing = ast.statements.find(
-    (s) => ts9.isImportDeclaration(s) && s.moduleSpecifier.text === "@osmo/scene" && !s.importClause?.isTypeOnly
+    (s) => ts11.isImportDeclaration(s) && s.moduleSpecifier.text === "@osmo/scene" && !s.importClause?.isTypeOnly
   );
   const bindings = existing?.importClause?.namedBindings;
-  if (bindings && ts9.isNamedImports(bindings)) {
+  if (bindings && ts11.isNamedImports(bindings)) {
     const missing = names.filter(
       (name) => !bindings.elements.some((e) => e.name.text === name)
     );
@@ -3995,19 +4141,19 @@ function addImports(text, names, declaration = "") {
   } else text = `import {${names.join(", ")}} from '@osmo/scene';
 ${text}`;
   if (declaration) {
-    const next = ts9.createSourceFile(
+    const next = ts11.createSourceFile(
       "scene.tsx",
       text,
-      ts9.ScriptTarget.Latest,
+      ts11.ScriptTarget.Latest,
       true,
-      ts9.ScriptKind.TSX
-    ), at = next.statements.find(ts9.isExportAssignment).getStart(next);
+      ts11.ScriptKind.TSX
+    ), at = next.statements.find(ts11.isExportAssignment).getStart(next);
     text = patches2(text, [{ start: at, end: at, text: declaration + "\n" }]);
   }
   return text;
 }
 function insertChild(text, node, child, ast, first = false) {
-  if (ts9.isJsxSelfClosingElement(node))
+  if (ts11.isJsxSelfClosingElement(node))
     return patches2(text, [
       {
         start: node.end - 2,
@@ -4026,7 +4172,7 @@ function findOpening(ast, start) {
   let found;
   function walk(n) {
     if (opening2(n)?.getStart(ast) === start) found = n;
-    else ts9.forEachChild(n, walk);
+    else ts11.forEachChild(n, walk);
   }
   walk(ast);
   return found;
@@ -4058,7 +4204,7 @@ function applyResourceSource(text, plan, {
     }
     selection = newId();
     if (plan.resource.kind === "scene") {
-      const imports = model.ast.statements.filter(ts9.isImportDeclaration);
+      const imports = model.ast.statements.filter(ts11.isImportDeclaration);
       const existing = imports.find(
         (st) => st.importClause?.name && (st.moduleSpecifier.text === src || definitions[st.importClause.name.text]?.source === plan.resource.entry)
       );
@@ -4092,12 +4238,12 @@ ${text}`;
       text = addImports(text, [plan.tag]);
     }
   } else {
-    const ast = ts9.createSourceFile(
+    const ast = ts11.createSourceFile(
       filename2,
       text,
-      ts9.ScriptTarget.Latest,
+      ts11.ScriptTarget.Latest,
       true,
-      ts9.ScriptKind.TSX
+      ts11.ScriptKind.TSX
     );
     const node = findOpening(ast, plan.node.source.start);
     if (!node) throw new Error("The target layer changed. Try again.");
@@ -4107,7 +4253,7 @@ ${text}`;
       );
       const id = first && attributes2(first).get("id")?.initializer;
       const value = unwrap2(id);
-      const replace = first && ["Image", "Video"].includes(opening2(first).tagName.getText(ast)) && value && ts9.isStringLiteral(value) && value.text.startsWith("fill-");
+      const replace = first && ["Image", "Video"].includes(opening2(first).tagName.getText(ast)) && value && ts11.isStringLiteral(value) && value.text.startsWith("fill-");
       const element = jsx(plan.tag, {
         id: replace ? value.text : `fill-${newId()}`,
         ...plan.props,
@@ -4127,7 +4273,7 @@ ${text}`;
       const attrs = attributes2(node), attr = attrs.get("effects"), array = unwrap2(attr?.initializer);
       const call2 = `${name}(${JSON.stringify(effect.values ?? {})})`;
       if (attr) {
-        if (!array || !ts9.isArrayLiteralExpression(array))
+        if (!array || !ts11.isArrayLiteralExpression(array))
           throw new Error("Edit this effect stack in source.");
         const last = array.elements.at(-1), at = last ? last.end : array.getStart(ast) + 1;
         text = patches2(text, [
@@ -4167,11 +4313,11 @@ var init_resource_source = __esm({
 });
 
 // src/timeline-editor.ts
-import fs7 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import { realpathSync } from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 import { createHash as createHash6, randomUUID as randomUUID7 } from "node:crypto";
-import ts10 from "typescript";
+import ts12 from "typescript";
 function createTimelineEditor(root, context, {
   nativeValidation = false,
   prepareCandidate,
@@ -4188,19 +4334,19 @@ function createTimelineEditor(root, context, {
   };
   async function read() {
     const { source: inputSource, scene } = context();
-    const source = await fs7.realpath(inputSource);
-    const text = await fs7.readFile(source, "utf8"), definitions = {}, inputs = /* @__PURE__ */ new Map([[source, text]]);
+    const source = await fs8.realpath(inputSource);
+    const text = await fs8.readFile(source, "utf8"), definitions = {}, inputs = /* @__PURE__ */ new Map([[source, text]]);
     async function dependencies(file, body3, depth = 0) {
       if (depth > 32) throw new Error("Too many imported animations");
-      const ast = ts10.createSourceFile(
+      const ast = ts12.createSourceFile(
         file,
         body3,
-        ts10.ScriptTarget.Latest,
+        ts12.ScriptTarget.Latest,
         true,
-        ts10.ScriptKind.TSX
+        ts12.ScriptKind.TSX
       );
       for (const st of ast.statements)
-        if (ts10.isImportDeclaration(st) && st.importClause?.name && // A module specifier is a string literal.
+        if (ts12.isImportDeclaration(st) && st.importClause?.name && // A module specifier is a string literal.
         st.moduleSpecifier.text.startsWith(".")) {
           const next = sceneInProject(
             root,
@@ -4208,7 +4354,7 @@ function createTimelineEditor(root, context, {
           );
           let code = inputs.get(next.source);
           if (code === void 0) {
-            code = await fs7.readFile(next.source, "utf8");
+            code = await fs8.readFile(next.source, "utf8");
             inputs.set(next.source, code);
             await dependencies(next.source, code, depth + 1);
           }
@@ -4257,7 +4403,7 @@ function createTimelineEditor(root, context, {
       ...data,
       sourceFiles: Object.fromEntries(
         [...inputs].map(([file, body3]) => [
-          path20.relative(root, file).split(path20.sep).join("/"),
+          path21.relative(root, file).split(path21.sep).join("/"),
           body3
         ])
       ),
@@ -4268,16 +4414,16 @@ function createTimelineEditor(root, context, {
     };
   }
   async function write(file, text) {
-    const temp = path20.join(
-      path20.dirname(file),
+    const temp = path21.join(
+      path21.dirname(file),
       `.osmo-edit-${randomUUID7()}.tmp`
     );
     try {
-      const mode = (await fs7.stat(file)).mode;
-      await fs7.writeFile(temp, text, { mode });
-      await fs7.rename(temp, file);
+      const mode = (await fs8.stat(file)).mode;
+      await fs8.writeFile(temp, text, { mode });
+      await fs8.rename(temp, file);
     } finally {
-      await fs7.rm(temp, { force: true });
+      await fs8.rm(temp, { force: true });
     }
   }
   return {
@@ -4290,27 +4436,27 @@ function createTimelineEditor(root, context, {
     resolveAdd: (cardId) => serial(async () => {
       const board = validateBoard(
         JSON.parse(
-          await fs7.readFile(
-            path20.join(root, "storyboard.canvas.json"),
+          await fs8.readFile(
+            path21.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 fs7.readFile(located.source, "utf8");
+      const located = sceneInProject(root, card.source), code = await fs8.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 fs7.readFile(sceneInProject(root, file).source, "utf8")
+              await fs8.readFile(sceneInProject(root, file).source, "utf8")
             ]
           )
         )
       );
-      let importPath = path20.relative(path20.dirname(context().source), located.source).split(path20.sep).join("/");
+      let importPath = path21.relative(path21.dirname(context().source), located.source).split(path21.sep).join("/");
       if (!importPath.startsWith(".")) importPath = "./" + importPath;
       return {
         type: "add",
@@ -4350,7 +4496,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 fs7.readFile(file, "utf8");
+        const current2 = await fs8.readFile(file, "utf8");
         if (current2 !== change.before)
           throw Object.assign(new Error(`Source changed: ${change.file}`), {
             status: 409
@@ -4384,7 +4530,7 @@ function createTimelineEditor(root, context, {
           status: 409
         });
       for (const change of changed)
-        if (await fs7.readFile(change.file, "utf8") !== change.before)
+        if (await fs8.readFile(change.file, "utf8") !== change.before)
           throw Object.assign(new Error("Source changed while validating"), {
             status: 409
           });
@@ -4396,7 +4542,7 @@ function createTimelineEditor(root, context, {
         }
       } catch (error) {
         for (const change of written.reverse())
-          if (await fs7.readFile(change.file, "utf8") === change.after)
+          if (await fs8.readFile(change.file, "utf8") === change.after)
             await write(change.file, change.before);
         throw error;
       }
@@ -4459,11 +4605,11 @@ 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 = path20.relative(path20.dirname(file), sceneInProject(root, value).source).split(path20.sep).join("/");
+          let p = path21.relative(path21.dirname(file), sceneInProject(root, value).source).split(path21.sep).join("/");
           return p.startsWith(".") ? p : "./" + p;
         };
         result = applyResourceSource(before.inputs.get(file), plan, {
-          filename: path20.relative(root, file),
+          filename: path21.relative(root, file),
           definitions: before.definitions,
           src: relative(resource.entry),
           effectSrc: resource.effect ? relative(resource.effect.src) : void 0,
@@ -4487,8 +4633,8 @@ function createTimelineEditor(root, context, {
         if (command.type === "add") {
           const board = validateBoard(
             JSON.parse(
-              await fs7.readFile(
-                path20.join(root, "storyboard.canvas.json"),
+              await fs8.readFile(
+                path21.join(root, "storyboard.canvas.json"),
                 "utf8"
               )
             )
@@ -4497,12 +4643,12 @@ function createTimelineEditor(root, context, {
           const { source: groupSource, scene: groupScene } = sceneInProject(
             root,
             card.source
-          ), code = await fs7.readFile(groupSource, "utf8");
+          ), code = await fs8.readFile(groupSource, "utf8");
           const definition = {
             ...describeGroup(code, groupScene),
             source: groupScene
           };
-          let importPath = path20.relative(path20.dirname(before.source), groupSource).split(path20.sep).join("/");
+          let importPath = path21.relative(path21.dirname(before.source), groupSource).split(path21.sep).join("/");
           if (!importPath.startsWith(".")) importPath = "./" + importPath;
           resolved = {
             type: "add",
@@ -4614,8 +4760,8 @@ var init_timeline_editor = __esm({
     init_resource_source();
     init_timeline();
     init_group_model();
-    resolveImport = (source, spec) => path20.resolve(
-      path20.dirname(source),
+    resolveImport = (source, spec) => path21.resolve(
+      path21.dirname(source),
       spec.endsWith(".tsx") ? spec : spec.endsWith(".js") ? spec.slice(0, -3) + ".tsx" : spec + ".tsx"
     );
     hash2 = (value) => createHash6("sha256").update(value).digest("hex");
@@ -4624,12 +4770,12 @@ var init_timeline_editor = __esm({
 
 // src/studio-settings.ts
 import { mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8, rename as rename3, rm as rm7 } from "node:fs/promises";
-import path21 from "node:path";
+import path22 from "node:path";
 import { randomBytes } from "node:crypto";
 async function studioSettings(root) {
-  const directory = path21.join(root, ".osmo");
+  const directory = path22.join(root, ".osmo");
   await mkdir8(directory, { recursive: true });
-  const lock = path21.join(directory, "studio.lock");
+  const lock = path22.join(directory, "studio.lock");
   const deadline = Date.now() + 5e3;
   while (true) {
     try {
@@ -4646,7 +4792,7 @@ async function studioSettings(root) {
   }
   const release = () => rm7(lock, { recursive: true, force: true });
   try {
-    const file = path21.join(directory, "studio.json");
+    const file = path22.join(directory, "studio.json");
     let settings, existing = false;
     try {
       settings = JSON.parse(await readFile8(file, "utf8"));
@@ -4658,7 +4804,7 @@ async function studioSettings(root) {
         throw new Error(
           "Cannot read .osmo/studio.json. Fix or remove it to reset the Studio address."
         );
-      const name = path21.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 = path22.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")}`,
@@ -4666,7 +4812,7 @@ async function studioSettings(root) {
         token: randomBytes(24).toString("hex")
       };
     }
-    const ignorePath = path21.join(root, ".gitignore");
+    const ignorePath = path22.join(root, ".gitignore");
     let ignore = "";
     try {
       ignore = await readFile8(ignorePath, "utf8");
@@ -4714,11 +4860,11 @@ var init_studio_settings = __esm({
 import { readFile as readFile9, writeFile as writeFile9, rename as rename4, mkdir as mkdir9 } from "node:fs/promises";
 import { userInfo } from "node:os";
 import { randomUUID as randomUUID8 } from "node:crypto";
-import path22 from "node:path";
+import path23 from "node:path";
 async function commentProfile(root) {
   try {
     const profile = JSON.parse(
-      await readFile9(path22.join(root, ".osmo/comment-profile.json"), "utf8")
+      await readFile9(path23.join(root, ".osmo/comment-profile.json"), "utf8")
     );
     if (!validAuthor(profile)) throw new Error("Invalid comment profile");
     return profile;
@@ -4737,11 +4883,11 @@ async function saveCommentProfile(root, input) {
     throw new Error(
       "Provide a name and a PNG, JPEG, or WebP avatar under 110 KB."
     );
-  const folder = path22.join(root, ".osmo");
+  const folder = path23.join(root, ".osmo");
   await mkdir9(folder, { recursive: true });
-  const temp = path22.join(folder, `comment-profile.${randomUUID8()}.tmp`);
+  const temp = path23.join(folder, `comment-profile.${randomUUID8()}.tmp`);
   await writeFile9(temp, JSON.stringify(profile) + "\n");
-  await rename4(temp, path22.join(folder, "comment-profile.json"));
+  await rename4(temp, path23.join(folder, "comment-profile.json"));
   return profile;
 }
 var init_comment_profile = __esm({
@@ -4757,16 +4903,16 @@ __export(server_exports, {
   startStudio: () => startStudio
 });
 import http from "node:http";
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import { readFile as readFile10, stat as stat4, realpath as realpath3, readdir as readdir3 } from "node:fs/promises";
-import path23 from "node:path";
+import path24 from "node:path";
 import { createHash as createHash7, randomUUID as randomUUID9 } from "node:crypto";
 import { spawn as spawn3 } from "node:child_process";
 async function revision(paths2) {
   const hash3 = createHash7("sha256");
   for (const file of [...new Set(paths2)].sort()) {
     hash3.update(file);
-    for await (const chunk of fs8.createReadStream(file)) hash3.update(chunk);
+    for await (const chunk of fs9.createReadStream(file)) hash3.update(chunk);
   }
   return `sha256:${hash3.digest("hex")}`;
 }
@@ -4783,7 +4929,7 @@ async function fingerprint(paths2) {
   ).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) => path23.join(studioRoot, file));
+  const files = (await readdir3(studioRoot, { recursive: true })).filter((file) => /\.(html|js|css|svg|woff2|ttf|wasm)$/.test(file)).sort().map((file) => path24.join(studioRoot, file));
   const stamp = await fingerprint(files);
   if (stamp !== studioStamp) {
     const digest = await revision(files);
@@ -4821,8 +4967,8 @@ async function startStudio({
   preview = {},
   open = true
 }) {
-  const studioBuild = path23.join(runtimeRoot, "packages/studio/tools/build.mjs");
-  if (fs8.existsSync(studioBuild))
+  const studioBuild = path24.join(runtimeRoot, "packages/studio/tools/build.mjs");
+  if (fs9.existsSync(studioBuild))
     await run(process.execPath, [studioBuild], { stdio: ["ignore", 2, 2] });
   root = await realpath3(root);
   source = await realpath3(source);
@@ -4859,7 +5005,7 @@ async function startStudio({
     scene,
     preview,
     version,
-    projectName: path23.basename(root),
+    projectName: path24.basename(root),
     projectId: settings.id,
     loading: true,
     error: null,
@@ -5056,7 +5202,7 @@ async function startStudio({
             "Content-Type": "application/octet-stream",
             "X-Content-Type-Options": "nosniff"
           });
-          const stream = fs8.createReadStream(file2.sourcePath);
+          const stream = fs9.createReadStream(file2.sourcePath);
           res.once("close", () => stream.destroy());
           stream.on("error", () => res.destroy()).pipe(res);
           return;
@@ -5112,6 +5258,8 @@ async function startStudio({
             types3[asset.extension] ?? "application/octet-stream"
           );
         }
+        if (req.method === "GET" && url2.pathname === "/api/scenes")
+          return json(res, 200, await listProjectScenes(root));
         if (req.method === "GET" && url2.pathname === "/api/resources")
           return json(
             res,
@@ -5301,14 +5449,14 @@ async function startStudio({
             geometry = {
               revision: rev,
               frame,
-              targets: result.targets.filter((t) => rows.has(t.path)).map(({ path: path25, ...t }, order) => ({
+              targets: result.targets.filter((t) => rows.has(t.path)).map(({ path: path26, ...t }, order) => ({
                 ...t,
                 // Filtered to rows above.
-                id: rows.get(path25),
+                id: rows.get(path26),
                 order
               })),
               quads: Object.fromEntries(
-                Object.entries(result.quads).filter(([path25]) => rows.has(path25)).map(([path25, quad]) => [rows.get(path25), quad])
+                Object.entries(result.quads).filter(([path26]) => rows.has(path26)).map(([path26, quad]) => [rows.get(path26), quad])
               )
             };
             geometryCache.set(key, geometry);
@@ -5451,7 +5599,7 @@ async function startStudio({
             "Content-Disposition": `attachment; filename*=UTF-8''${encodeURIComponent(file2.name)}`,
             "X-Content-Type-Options": "nosniff"
           });
-          const stream = fs8.createReadStream(filename2);
+          const stream = fs9.createReadStream(filename2);
           res.once("close", () => stream.destroy());
           stream.on("error", () => res.destroy()).pipe(res);
           return;
@@ -5550,15 +5698,15 @@ 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 ?? `${path23.basename(scene, ".tsx")}-${Date.now()}.${format2.extension}`;
+            const filename2 = input.filename ?? `${path24.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 = path23.join(root, "exports");
-            await fs8.promises.mkdir(folder, { recursive: true });
+            const folder = path24.join(root, "exports");
+            await fs9.promises.mkdir(folder, { recursive: true });
             const canonicalFolder = await realpath3(folder);
-            if (path23.relative(root, canonicalFolder).startsWith(".."))
+            if (path24.relative(root, canonicalFolder).startsWith(".."))
               throw new Error("Export folder must stay inside the project");
-            const destination = path23.join(canonicalFolder, filename2);
+            const destination = path24.join(canonicalFolder, filename2);
             if (closed || project !== snapshot || state.loading || editing || dirty)
               throw Object.assign(
                 new Error("The scene changed before export. Try again."),
@@ -5634,7 +5782,7 @@ async function startStudio({
           `${cookieName}=${token}; HttpOnly; SameSite=Strict; Path=${projectPath}; Max-Age=31536000`
         );
       const file = isPage ? "index.html" : url2.pathname.slice(1);
-      if (!/^(index\.html|public\/(osmo-studio-logo|pencil-simple|check-circle-filled)\.svg|src\/[\w/-]+\.(js|css|wasm|svg|woff2)|public\/comment-cursor\/(default|active-outer)\.svg|public\/fonts\/[\w-]+\.woff2)$/.test(
+      if (!/^(index\.html|public\/(osmo-studio-logo|pencil-simple|check-circle-filled)\.svg|src\/[\w/-]+\.(js|css|wasm|svg|woff2|ttf)|public\/comment-cursor\/(default|active-outer)\.svg|public\/fonts\/[\w-]+\.woff2)$/.test(
         file
       ))
         return json(res, 404, { error: "Not found" });
@@ -5644,15 +5792,16 @@ async function startStudio({
         ".js": "text/javascript",
         ".css": "text/css",
         ".woff2": "font/woff2",
+        ".ttf": "font/ttf",
         ".svg": "image/svg+xml"
       };
-      const bytes = await readFile10(path23.join(studioRoot, file));
+      const bytes = await readFile10(path24.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": types2[path23.extname(file)],
+        "Content-Type": types2[path24.extname(file)],
         "Cache-Control": "no-cache"
       });
       res.end(bytes);
@@ -5768,16 +5917,16 @@ async function startStudio({
   const url = `http://127.0.0.1:${settings.port}${projectPath}`;
   openBrowser(url);
   try {
-    watcher = fs8.watch(root, { recursive: true }, async (event, filename2) => {
+    watcher = fs9.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/") || name === "assets" || name.startsWith("assets/")) && !dependencies.includes(path23.join(root, name)))
+      if ((name.startsWith("resources/") || name === "assets" || name.startsWith("assets/")) && !dependencies.includes(path24.join(root, name)))
         return;
-      const file = path23.join(root, name), before = watchedStamps.get(file);
+      const file = path24.join(root, name), before = watchedStamps.get(file);
       const next = await fingerprint([file]);
       watchedStamps.set(file, next);
       if (closed || editing) return;
@@ -5804,6 +5953,7 @@ var studioStamp, studioDigest;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
+    init_project_scenes();
     init_asset_response();
     init_attachment_thumbnail();
     init_local_attachment_picker();
@@ -5827,7 +5977,7 @@ var init_server = __esm({
 init_check();
 import { existsSync as existsSync3, statSync } from "node:fs";
 import { mkdir as mkdir10, readFile as readFile11, rename as rename5, rm as rm8 } from "node:fs/promises";
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/cloud.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -8714,7 +8864,7 @@ async function checked(root, source) {
   const seen = /* @__PURE__ */ new Set();
   return issues.map((issue) => ({
     ...issue,
-    ...issue.file && path24.isAbsolute(issue.file) ? { file: path24.relative(root, issue.file) } : {}
+    ...issue.file && path25.isAbsolute(issue.file) ? { file: path25.relative(root, issue.file) } : {}
   })).filter((issue) => {
     const key = JSON.stringify(issue);
     return !seen.has(key) && seen.add(key);
@@ -8800,7 +8950,7 @@ var STUDIO = {
     run: async ([project, folder]) => {
       const done = await clone(
         parseProject(project),
-        folder === void 0 ? void 0 : path24.resolve(folder)
+        folder === void 0 ? void 0 : path25.resolve(folder)
       );
       return {
         status: "cloned",
@@ -8885,15 +9035,15 @@ ${r.status === "running" ? "Ctrl+C stops the server and renderer." : "Using the
       );
       const still = at !== void 0;
       const extension = still ? ".png" : ".mp4";
-      const name = path24.basename(scene, path24.extname(scene));
-      const out = path24.resolve(
-        flags.out ?? path24.join(
+      const name = path25.basename(scene, path25.extname(scene));
+      const out = path25.resolve(
+        flags.out ?? path25.join(
           root,
           "exports",
           `${name}${still ? `-${at}s` : ""}${extension}`
         )
       );
-      if (path24.extname(out).toLowerCase() !== extension)
+      if (path25.extname(out).toLowerCase() !== extension)
         throw new UsageError(
           still ? "With --at, --out names a .png file." : "--out names an .mp4 file. For one frame as a .png, add --at SECONDS.",
           "osmo studio render --help"
@@ -8927,10 +9077,10 @@ ${r.status === "running" ? "Ctrl+C stops the server and renderer." : "Using the
           "osmo studio render --help"
         );
       const frame = still ? Math.min(Math.round(at * fps), frames - 1) : void 0;
-      await mkdir10(path24.dirname(out), { recursive: true });
-      const partial = path24.join(
-        path24.dirname(out),
-        `.${path24.basename(out, extension)}.${process.pid}${extension}`
+      await mkdir10(path25.dirname(out), { recursive: true });
+      const partial = path25.join(
+        path25.dirname(out),
+        `.${path25.basename(out, extension)}.${process.pid}${extension}`
       );
       try {
         await runRenderer(