@vosjs/cli 0.35.0 → 0.37.0

package/dist/{chunk-VQXOM2NU.js → chunk-DD6OXVFJ.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-NHKHTIDR.js";
 
 // src/plugin/run.ts
-import { mkdir as mkdir9, readFile as readFile15, rm as rm4 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile15, rm as rm5 } from "fs/promises";
 import { existsSync as existsSync15 } from "fs";
 import { join as join18, resolve as resolve9 } from "path";
 import {
@@ -1681,6 +1681,378 @@ function framingWarnings(docIn, doc, zoom, overlays, warnings) {
   }
 }
 
+// src/plugin/container.ts
+var OCTET_STREAM = "application/octet-stream";
+var TYPES_BY_EXTENSION = {
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  avif: "image/avif",
+  webm: "video/webm",
+  mp4: "video/mp4",
+  mov: "video/quicktime",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  m4a: "audio/mp4"
+};
+var EXTENSION_BY_TYPE = {
+  "image/jpeg": ".jpg",
+  "video/mp4": ".mp4",
+  "audio/mp4": ".m4a"
+};
+var TAKE_MEDIA_EXTENSIONS = [
+  ".webm",
+  ".mp4",
+  ".mov",
+  ".m4a",
+  ".mp3",
+  ".ogg",
+  ".wav"
+];
+var MEDIA_HEAD_BYTES = 16;
+var ISO_BRANDS = {
+  "qt  ": "video/quicktime",
+  "M4A ": "audio/mp4",
+  "M4B ": "audio/mp4",
+  avif: "image/avif",
+  avis: "image/avif"
+};
+var RIFF_FORMS = {
+  WEBP: "image/webp",
+  WAVE: "audio/wav",
+  "AVI ": "video/x-msvideo"
+};
+function sniffMediaType(head) {
+  const ascii = (at2, len) => head.length >= at2 + len ? String.fromCharCode(...head.subarray(at2, at2 + len)) : "";
+  const startsWith = (...bytes) => bytes.every((b, i) => head[i] === b);
+  if (startsWith(26, 69, 223, 163)) return "video/webm";
+  if (ascii(4, 4) === "ftyp") return ISO_BRANDS[ascii(8, 4)] ?? "video/mp4";
+  if (ascii(0, 4) === "RIFF") return RIFF_FORMS[ascii(8, 4)] ?? null;
+  if (startsWith(137, 80, 78, 71, 13, 10, 26, 10))
+    return "image/png";
+  if (startsWith(255, 216, 255)) return "image/jpeg";
+  if (ascii(0, 4) === "GIF8") return "image/gif";
+  if (ascii(0, 4) === "OggS") return "audio/ogg";
+  if (ascii(0, 3) === "ID3") return "audio/mpeg";
+  return null;
+}
+function bareType(value) {
+  const type = (value ?? "").split(";")[0].trim().toLowerCase();
+  return !type || type === OCTET_STREAM || type === "binary/octet-stream" ? "" : type;
+}
+function mediaContentType(file) {
+  const ext = (/\.([a-z0-9]+)$/i.exec(file)?.[1] ?? "").toLowerCase();
+  return TYPES_BY_EXTENSION[ext] ?? OCTET_STREAM;
+}
+function extensionFor(contentType) {
+  const type = (contentType ?? "").split(";")[0].trim().toLowerCase();
+  if (EXTENSION_BY_TYPE[type]) return EXTENSION_BY_TYPE[type];
+  const ext = Object.keys(TYPES_BY_EXTENSION).find(
+    (e) => TYPES_BY_EXTENSION[e] === type
+  );
+  return ext ? `.${ext}` : "";
+}
+function resolveMediaType(claims) {
+  const sniffed = claims.head?.length ? sniffMediaType(claims.head) : null;
+  if (sniffed) return { type: sniffed, from: "bytes" };
+  const declared = bareType(claims.declared);
+  if (declared) return { type: declared, from: "declared" };
+  const named = mediaContentType(claims.filename ?? "");
+  if (named !== OCTET_STREAM) return { type: named, from: "filename" };
+  return { type: OCTET_STREAM, from: "unknown" };
+}
+function nameForType(filename, type) {
+  const ext = extensionFor(type);
+  if (!ext) return filename;
+  const current = /\.[a-z0-9]+$/i.exec(filename)?.[0] ?? "";
+  if (current && mediaContentType(`x${current}`) === type) return filename;
+  return `${filename.slice(0, filename.length - current.length)}${ext}`;
+}
+function containerMismatch(filename, head) {
+  const actual = sniffMediaType(head);
+  if (!actual) return null;
+  const claimed = mediaContentType(filename);
+  if (claimed === actual) return null;
+  return `${filename} is ${actual}, not the ${claimed} its name claims \u2014 rename it to ${nameForType(filename, actual)}`;
+}
+
+// src/plugin/media.ts
+import { isKeyedOverlay } from "@vosjs/studio-core";
+import { createWriteStream, existsSync as existsSync2 } from "fs";
+import {
+  mkdir as mkdir2,
+  open,
+  readdir,
+  rename as rename2,
+  rm as rm2,
+  stat,
+  writeFile as writeFile2
+} from "fs/promises";
+import { basename as basename2, dirname, join as join2 } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+
+// src/plugin/take.ts
+import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { basename, join } from "path";
+var RECORDING_NAME = "recording.webm";
+function takeMediaFiles(dir, stem) {
+  return TAKE_MEDIA_EXTENSIONS.map((ext) => join(dir, `${stem}${ext}`)).filter(
+    (file) => existsSync(file)
+  );
+}
+function takeMediaFile(dir, stem, fallback) {
+  return takeMediaFiles(dir, stem)[0] ?? join(dir, fallback);
+}
+var PREV_DOC_NAME = "doc.prev.json";
+function takePaths(dir) {
+  const recording = takeMediaFile(dir, "recording", RECORDING_NAME);
+  return {
+    dir,
+    recording,
+    recordingName: basename(recording),
+    framesDir: join(dir, "frames"),
+    framesIndex: join(dir, "frames.json"),
+    cursor: join(dir, "cursor.json"),
+    meta: join(dir, "meta.json"),
+    actions: join(dir, "actions.json"),
+    doc: join(dir, "doc.json")
+  };
+}
+async function ensureTakeDir(dir) {
+  const p = takePaths(dir);
+  await mkdir(p.framesDir, { recursive: true });
+  return p;
+}
+async function prepareReRecord(dir) {
+  const p = takePaths(dir);
+  const kept = [];
+  let prevDoc = false;
+  if (existsSync(p.doc)) {
+    await rename(p.doc, join(dir, PREV_DOC_NAME));
+    prevDoc = true;
+    kept.push(PREV_DOC_NAME);
+  }
+  if (existsSync(p.actions)) kept.push("actions.json");
+  if (existsSync(join(dir, "vos.json"))) kept.push("vos.json");
+  for (const stale of [
+    // Every container, not just the one `record` writes: a pulled take's
+    // footage may be mp4, and a survivor would outrank the new recording.
+    ...takeMediaFiles(dir, "recording"),
+    ...takeMediaFiles(dir, "mic"),
+    ...takeMediaFiles(dir, "cam"),
+    p.cursor,
+    p.meta,
+    p.framesIndex,
+    p.framesDir,
+    join(dir, "stills"),
+    join(dir, "digest")
+  ]) {
+    await rm(stale, { recursive: true, force: true });
+  }
+  return { prevDoc, kept };
+}
+async function readJson(file) {
+  return JSON.parse(await readFile(file, "utf8"));
+}
+async function writeJson(file, value, pretty = false) {
+  await writeFile(
+    file,
+    pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)
+  );
+}
+async function loadTake(dir) {
+  const paths = takePaths(dir);
+  if (!existsSync(paths.meta)) {
+    throw new Error(
+      `${dir} is not a take directory (missing meta.json) \u2014 run record first`
+    );
+  }
+  const meta = await readJson(paths.meta);
+  const cursor = existsSync(paths.cursor) ? await readJson(paths.cursor) : [];
+  const actions = existsSync(paths.actions) ? await readJson(paths.actions) : null;
+  const doc = existsSync(paths.doc) ? await readJson(paths.doc) : null;
+  return { paths, cursor, meta, actions, doc };
+}
+
+// src/plugin/media.ts
+var SOURCE_MEDIA = [
+  { key: "videoKey", stem: "recording", fallbackExt: ".webm" },
+  { key: "micKey", stem: "mic", fallbackExt: ".webm" },
+  { key: "camKey", stem: "cam", fallbackExt: ".webm" }
+];
+function isTakeRelativeKey(key) {
+  return !!key && !/^(https?:|blob:|data:|media:|\/\/)/.test(key) && !key.startsWith("/api/");
+}
+var takeRelativeFile = (key) => key.replace(/^\/+/, "");
+function docMediaRefs(doc, keep = isTakeRelativeKey) {
+  const out = [];
+  for (const m of doc.media ?? []) {
+    if (keep(m.videoKey))
+      out.push({
+        where: `media ${m.id}`,
+        key: m.videoKey,
+        set: (next) => {
+          m.videoKey = next;
+        }
+      });
+    const mic = m.micKey;
+    if (mic && keep(mic))
+      out.push({
+        where: `media ${m.id} mic`,
+        key: mic,
+        set: (next) => {
+          m.micKey = next;
+        }
+      });
+    const cam = m.camKey;
+    if (cam && keep(cam))
+      out.push({
+        where: `media ${m.id} cam`,
+        key: cam,
+        set: (next) => {
+          m.camKey = next;
+        }
+      });
+  }
+  for (const clip of doc.overlays ?? []) {
+    if (!isKeyedOverlay(clip) || !keep(clip.key)) continue;
+    out.push({
+      where: `overlay ${clip.id}`,
+      key: clip.key,
+      set: (next) => {
+        clip.key = next;
+      }
+    });
+  }
+  const mark = doc.endCard?.mark;
+  if (mark && keep(mark.key))
+    out.push({
+      where: "end card mark",
+      key: mark.key,
+      set: (next) => {
+        mark.key = next;
+      }
+    });
+  const bg = doc.frame.backgroundMedia;
+  if (bg && keep(bg.key))
+    out.push({
+      where: "background",
+      key: bg.key,
+      set: (next) => {
+        bg.key = next;
+      }
+    });
+  return out;
+}
+function assetIdOf(url) {
+  if (!url) return null;
+  const m = /\/api\/assets\/([A-Za-z0-9_-]+)\/file/.exec(url);
+  return m ? m[1] : null;
+}
+async function readMediaHead(file) {
+  const handle = await open(file, "r");
+  try {
+    const buf = Buffer.alloc(MEDIA_HEAD_BYTES);
+    const { bytesRead } = await handle.read(buf, 0, MEDIA_HEAD_BYTES, 0);
+    return new Uint8Array(buf.subarray(0, bytesRead));
+  } finally {
+    await handle.close();
+  }
+}
+async function downloadMedia(ctx, url, target) {
+  const abs = /^https?:/.test(url) ? url : `${ctx.origin}${url}`;
+  const res = await fetch(abs, {
+    headers: ctx.key ? { authorization: `Bearer ${ctx.key}` } : {}
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(
+      `download of ${target.describe} failed (${res.status})${res.status === 404 && target.notFoundHint ? ` \u2014 ${target.notFoundHint}` : ""}`
+    );
+  }
+  const into = target.subdir ? join2(target.dir, target.subdir) : target.dir;
+  const partial = join2(into, `${target.stem}.part`);
+  await mkdir2(dirname(partial), { recursive: true });
+  try {
+    await pipeline(
+      Readable.fromWeb(res.body),
+      createWriteStream(partial)
+    );
+    const { type } = resolveMediaType({
+      head: await readMediaHead(partial),
+      declared: res.headers.get("content-type"),
+      filename: `${target.stem}${target.fallbackExt}`
+    });
+    const name = `${target.stem}${extensionFor(type) || target.fallbackExt}`;
+    await rename2(partial, join2(into, name));
+    const file = target.subdir ? `${target.subdir}/${name}` : name;
+    return { file, bytes: (await stat(join2(target.dir, file))).size };
+  } finally {
+    await rm2(partial, { force: true });
+  }
+}
+async function pullMedia(ctx, dir, doc, log) {
+  const result = { downloaded: [], kept: [] };
+  for (const { key, stem, fallbackExt } of SOURCE_MEDIA) {
+    const url = doc.source[key];
+    const assetId = assetIdOf(url);
+    if (!assetId) continue;
+    const present = takeMediaFiles(dir, stem)[0];
+    if (present) {
+      result.kept.push(basename2(present));
+      doc.source[key] = basename2(present);
+      continue;
+    }
+    const got = await downloadMedia(ctx, url, {
+      dir,
+      stem,
+      fallbackExt,
+      describe: stem,
+      notFoundHint: "a private recording needs a content key of its owner"
+    });
+    result.downloaded.push({ file: got.file, assetId, bytes: got.bytes });
+    log(`  ${got.file} \u2190 asset ${assetId} (${Math.round(got.bytes / 1024)} kB)`);
+    doc.source[key] = got.file;
+  }
+  for (const ref of docMediaRefs(doc, (k) => assetIdOf(k) !== null)) {
+    const assetId = assetIdOf(ref.key);
+    const existing = existsSync2(join2(dir, "media")) ? (await readdir(join2(dir, "media"))).find(
+      (f) => f === assetId || f.startsWith(`${assetId}.`)
+    ) : void 0;
+    if (existing) {
+      const file = `media/${existing}`;
+      result.kept.push(file);
+      ref.set(file);
+      continue;
+    }
+    const got = await downloadMedia(ctx, ref.key, {
+      dir,
+      subdir: "media",
+      stem: assetId,
+      // A type with no extension here (an svg served as such) keeps the bare
+      // asset id, exactly as before.
+      fallbackExt: "",
+      describe: `${ref.where} (${ref.key})`
+    });
+    result.downloaded.push({ file: got.file, assetId, bytes: got.bytes });
+    log(
+      `  ${got.file} \u2190 ${ref.where}, asset ${assetId} (${Math.round(got.bytes / 1024)} kB)`
+    );
+    ref.set(got.file);
+  }
+  const metaPath = join2(dir, "meta.json");
+  if (!existsSync2(metaPath)) await writeJson(metaPath, doc.source.meta, true);
+  const cursorPath = join2(dir, "cursor.json");
+  if (!existsSync2(cursorPath)) await writeJson(cursorPath, doc.source.cursor);
+  await writeFile2(join2(dir, "doc.json"), JSON.stringify(doc, null, 2));
+  return result;
+}
+
 // src/plugin/mediaProbe.ts
 var MEDIA_EXT = /\.(png|jpe?g|webp|gif|webm|mp4|mov|mp3|wav|m4a|ogg|glb|gltf|hdr|exr|woff2?)($|\?)/i;
 var isRemote = (v) => typeof v === "string" && /^https?:\/\//i.test(v);
@@ -1766,9 +2138,9 @@ function mediaProbeLints(results) {
 }
 
 // src/plugin/framesTake.ts
-import { mkdir as mkdir3, readFile as readFile4, rename as rename3, writeFile as writeFile4 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import { join as join4, resolve as resolve2 } from "path";
+import { mkdir as mkdir4, readFile as readFile4, rename as rename4, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5, resolve as resolve2 } from "path";
 import { compileVosConfig } from "@vosjs/core";
 import {
   docStillTime,
@@ -1780,83 +2152,11 @@ import {
   spanOutputExtent as spanOutputExtent2
 } from "@vosjs/studio-core";
 
-// src/plugin/take.ts
-import { mkdir, readFile, rename, rm, writeFile } from "fs/promises";
-import { existsSync } from "fs";
-import { join } from "path";
-var RECORDING_NAME = "recording.webm";
-var PREV_DOC_NAME = "doc.prev.json";
-function takePaths(dir) {
-  return {
-    dir,
-    recording: join(dir, RECORDING_NAME),
-    framesDir: join(dir, "frames"),
-    framesIndex: join(dir, "frames.json"),
-    cursor: join(dir, "cursor.json"),
-    meta: join(dir, "meta.json"),
-    actions: join(dir, "actions.json"),
-    doc: join(dir, "doc.json")
-  };
-}
-async function ensureTakeDir(dir) {
-  const p = takePaths(dir);
-  await mkdir(p.framesDir, { recursive: true });
-  return p;
-}
-async function prepareReRecord(dir) {
-  const p = takePaths(dir);
-  const kept = [];
-  let prevDoc = false;
-  if (existsSync(p.doc)) {
-    await rename(p.doc, join(dir, PREV_DOC_NAME));
-    prevDoc = true;
-    kept.push(PREV_DOC_NAME);
-  }
-  if (existsSync(p.actions)) kept.push("actions.json");
-  if (existsSync(join(dir, "vos.json"))) kept.push("vos.json");
-  for (const stale of [
-    p.recording,
-    p.cursor,
-    p.meta,
-    p.framesIndex,
-    p.framesDir,
-    join(dir, "stills"),
-    join(dir, "digest"),
-    join(dir, "mic.webm"),
-    join(dir, "cam.webm")
-  ]) {
-    await rm(stale, { recursive: true, force: true });
-  }
-  return { prevDoc, kept };
-}
-async function readJson(file) {
-  return JSON.parse(await readFile(file, "utf8"));
-}
-async function writeJson(file, value, pretty = false) {
-  await writeFile(
-    file,
-    pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)
-  );
-}
-async function loadTake(dir) {
-  const paths = takePaths(dir);
-  if (!existsSync(paths.meta)) {
-    throw new Error(
-      `${dir} is not a take directory (missing meta.json) \u2014 run record first`
-    );
-  }
-  const meta = await readJson(paths.meta);
-  const cursor = existsSync(paths.cursor) ? await readJson(paths.cursor) : [];
-  const actions = existsSync(paths.actions) ? await readJson(paths.actions) : null;
-  const doc = existsSync(paths.doc) ? await readJson(paths.doc) : null;
-  return { paths, cursor, meta, actions, doc };
-}
-
 // src/plugin/server.ts
 import { createServer } from "http";
-import { existsSync as existsSync2, readFileSync, statSync } from "fs";
-import { writeFile as writeFile2 } from "fs/promises";
-import { extname, join as join2 } from "path";
+import { existsSync as existsSync3, readFileSync, statSync } from "fs";
+import { writeFile as writeFile3 } from "fs/promises";
+import { extname, join as join3 } from "path";
 var MIME = {
   ".html": "text/html",
   ".js": "text/javascript",
@@ -1890,7 +2190,7 @@ function startTakeServer(rootDir, pages) {
       const chunks = [];
       req.on("data", (c) => chunks.push(c));
       req.on("end", () => {
-        void writeFile2(join2(rootDir, name), Buffer.concat(chunks)).then(
+        void writeFile3(join3(rootDir, name), Buffer.concat(chunks)).then(
           () => res.writeHead(200).end("ok"),
           (e) => res.writeHead(500).end(String(e))
         );
@@ -1902,11 +2202,11 @@ function startTakeServer(rootDir, pages) {
       res.end(pages[url.pathname]);
       return;
     }
-    const file = join2(rootDir, decodeURIComponent(url.pathname));
-    if (existsSync2(file) && statSync(file).isFile()) {
-      const type = MIME[extname(file)] ?? "application/octet-stream";
+    const file = join3(rootDir, decodeURIComponent(url.pathname));
+    if (existsSync3(file) && statSync(file).isFile()) {
       const size = statSync(file).size;
       const buf = readFileSync(file);
+      const type = sniffMediaType(buf.subarray(0, MEDIA_HEAD_BYTES)) ?? MIME[extname(file)] ?? "application/octet-stream";
       const range = req.headers.range;
       const m = range && /^bytes=(\d*)-(\d*)$/.exec(range);
       if (m) {
@@ -1969,7 +2269,7 @@ async function waitForPageDone(page, label, onProgress, timeoutMs) {
 }
 
 // src/plugin/renderAnimation.ts
-import { readFile as readFile2, rm as rm2 } from "fs/promises";
+import { readFile as readFile2, rm as rm3 } from "fs/promises";
 import { tweenRuntimeCode } from "@vosjs/tween/bundle";
 import { elementsBundleCode } from "@vosjs/elements/bundle";
 import { concatEncodedVideo, planChunks } from "@vosjs/render-core";
@@ -2267,7 +2567,7 @@ async function renderAnimation(browser, opts) {
       outNames.map((name) => readFile2(`${opts.workDir}/${name}`))
     );
     await Promise.all(
-      outNames.map((name) => rm2(`${opts.workDir}/${name}`, { force: true }))
+      outNames.map((name) => rm3(`${opts.workDir}/${name}`, { force: true }))
     );
     if (chunks.length === 1) {
       return { bytes: new Uint8Array(files[0]), totalFrames, chunks: 1 };
@@ -2522,9 +2822,9 @@ function applyAndValidate(doc, o) {
 }
 
 // src/plugin/digestTake.ts
-import { mkdir as mkdir2, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join3, resolve } from "path";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename3, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, resolve } from "path";
 import {
   DIGEST_CROP_MAX,
   DIGEST_FULL_MAX,
@@ -2746,8 +3046,8 @@ async function digestTake(browser, dir, opts = {}) {
   const meta = doc.source.meta;
   let plan = planForDigest(doc);
   const transcript = opts.transcript ?? await discoverTranscript(dir);
-  const outDir = resolve(opts.outDir ?? join3(dir, DIGEST_DIR));
-  await mkdir2(outDir, { recursive: true });
+  const outDir = resolve(opts.outDir ?? join4(dir, DIGEST_DIR));
+  await mkdir3(outDir, { recursive: true });
   const fullMax = opts.full ?? DIGEST_FULL_MAX;
   const cropMax = opts.crop ?? DIGEST_CROP_MAX;
   const wantFrames = opts.frames !== false && browser !== null;
@@ -2759,8 +3059,11 @@ async function digestTake(browser, dir, opts = {}) {
   let sheet = null;
   let moments;
   const boxes = /* @__PURE__ */ new Map();
-  let source = { kind: "video", url: `/${RECORDING_NAME}` };
-  if (existsSync3(take.paths.framesIndex) && existsSync3(take.paths.framesDir)) {
+  let source = {
+    kind: "video",
+    url: `/${take.paths.recordingName}`
+  };
+  if (existsSync4(take.paths.framesIndex) && existsSync4(take.paths.framesDir)) {
     const index = await readJson(
       take.paths.framesIndex
     );
@@ -2775,9 +3078,9 @@ async function digestTake(browser, dir, opts = {}) {
     }
   }
   if (wantFrames) {
-    if (source.kind === "video" && !existsSync3(take.paths.recording))
+    if (source.kind === "video" && !existsSync4(take.paths.recording))
       throw new Error(
-        `${dir} has no ${RECORDING_NAME} \u2014 pull it with \`vos pull --media\` first`
+        `${dir} has no recording \u2014 pull it with \`vos pull --media\` first`
       );
     const server = await startTakeServer(dir, {
       "/digest.html": digestPageHtml()
@@ -2848,9 +3151,9 @@ async function digestTake(browser, dir, opts = {}) {
       );
       sizes = f.sizes;
       for (const name of Object.keys(sizes)) {
-        const from = join3(dir, name);
-        const to = join3(outDir, name);
-        if (from !== to && existsSync3(from)) await rename2(from, to);
+        const from = join4(dir, name);
+        const to = join4(outDir, name);
+        if (from !== to && existsSync4(from)) await rename3(from, to);
       }
       if (sizes["sheet.png"]) sheet = "sheet.png";
     } finally {
@@ -2876,12 +3179,12 @@ async function digestTake(browser, dir, opts = {}) {
         if (!p) continue;
         for (const f of [p.full, p.crop]) {
           if (!f) continue;
-          const size = await pngSize(join3(outDir, f));
+          const size = await pngSize(join4(outDir, f));
           if (size) sizes[f] = size;
         }
         if (p.box) boxes.set(m.id, p.box);
       }
-      if (prior.images.sheet && existsSync3(join3(outDir, prior.images.sheet)))
+      if (prior.images.sheet && existsSync4(join4(outDir, prior.images.sheet)))
         sheet = prior.images.sheet;
     }
   }
@@ -2910,14 +3213,14 @@ async function digestTake(browser, dir, opts = {}) {
     style: opts.style ?? null,
     transcript
   });
-  const file = join3(outDir, "digest.json");
+  const file = join4(outDir, "digest.json");
   const body = JSON.stringify(digest, null, 2);
-  await writeFile3(file, body);
+  await writeFile4(file, body);
   return { file, outDir, digest, bytes: Buffer.byteLength(body) };
 }
 async function discoverTranscript(dir) {
-  const file = join3(dir, "transcript.json");
-  if (!existsSync3(file)) return null;
+  const file = join4(dir, "transcript.json");
+  if (!existsSync4(file)) return null;
   try {
     return parseTranscript(JSON.parse(await readFile3(file, "utf8")));
   } catch {
@@ -2927,7 +3230,7 @@ async function discoverTranscript(dir) {
 async function readPriorDigest(outDir) {
   try {
     const raw = JSON.parse(
-      await readFile3(join3(outDir, "digest.json"), "utf8")
+      await readFile3(join4(outDir, "digest.json"), "utf8")
     );
     return raw.digestVersion === DIGEST_VERSION && Array.isArray(raw.moments) ? raw : null;
   } catch {
@@ -3111,8 +3414,8 @@ async function framesTake(browser, dir, opts) {
     throw new Error(
       "no frame times \u2014 pass --times/--frame, --at-zooms, --at-moments or --at-still"
     );
-  const outDir = resolve2(opts.outDir ?? join4(dir, "stills"));
-  await mkdir3(outDir, { recursive: true });
+  const outDir = resolve2(opts.outDir ?? join5(dir, "stills"));
+  await mkdir4(outDir, { recursive: true });
   const named = shots.map((s, i) => ({
     ...s,
     name: s.kind === "moment" ? `moment-${s.momentId}-${s.time.toFixed(2)}s.png` : `${s.kind === "zoom" ? "zoom" : "frame"}-${String(i).padStart(2, "0")}-${s.time.toFixed(2)}s.png`
@@ -3140,7 +3443,7 @@ async function framesTake(browser, dir, opts) {
     void page.evaluate(stillsInPage, {
       animationCode,
       token: VIDEO_TOKEN,
-      videoUrl: `/${RECORDING_NAME}`,
+      videoUrl: `/${take.paths.recordingName}`,
       W: width,
       H: height,
       ss,
@@ -3156,9 +3459,9 @@ async function framesTake(browser, dir, opts) {
     );
     const frames = [];
     for (const n of named) {
-      const from = join4(dir, n.name);
-      const to = join4(outDir, n.name);
-      if (from !== to) await rename3(from, to);
+      const from = join5(dir, n.name);
+      const to = join5(outDir, n.name);
+      if (from !== to) await rename4(from, to);
       frames.push({
         file: to,
         time: n.time,
@@ -3173,8 +3476,8 @@ async function framesTake(browser, dir, opts) {
   }
 }
 async function momentsFor(dir, doc) {
-  const file = join4(dir, DIGEST_DIR, "digest.json");
-  if (existsSync4(file)) {
+  const file = join5(dir, DIGEST_DIR, "digest.json");
+  if (existsSync5(file)) {
     try {
       const d = JSON.parse(await readFile4(file, "utf8"));
       if (Array.isArray(d.moments)) return d.moments;
@@ -3196,8 +3499,8 @@ function parseTimes(spec, duration) {
   });
 }
 async function writeIndexJson(result) {
-  const index = join4(result.outDir, "stills.json");
-  await writeFile4(
+  const index = join5(result.outDir, "stills.json");
+  await writeFile5(
     index,
     JSON.stringify(
       {
@@ -3214,10 +3517,10 @@ async function writeIndexJson(result) {
 }
 
 // src/plugin/deliver.ts
-import { mkdir as mkdir4, mkdtemp, rename as rename4, rm as rm3, stat, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir5, mkdtemp, rename as rename5, rm as rm4, stat as stat2, writeFile as writeFile7 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join7, relative, resolve as resolve4 } from "path";
-import { existsSync as existsSync6 } from "fs";
+import { join as join8, relative, resolve as resolve4 } from "path";
+import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile6 } from "fs/promises";
 import { parseFrontmatter } from "@vosjs/shared/frontmatter";
 import {
@@ -3232,7 +3535,7 @@ import {
 } from "@vosjs/studio-core";
 
 // src/plugin/renderTake.ts
-import { writeFile as writeFile5 } from "fs/promises";
+import { writeFile as writeFile6 } from "fs/promises";
 import { compileVosConfig as compileVosConfig2 } from "@vosjs/core";
 import {
   audioProducerCode,
@@ -3304,7 +3607,7 @@ async function renderTake(browser, dir, outFile, opts) {
   const result = await renderAnimation(browser, {
     animationCode,
     workDir: dir,
-    videoFile: RECORDING_NAME,
+    videoFile: take.paths.recordingName,
     videoToken: VIDEO_TOKEN2,
     width,
     height,
@@ -3321,7 +3624,7 @@ async function renderTake(browser, dir, outFile, opts) {
     } : void 0,
     onProgress: opts.onProgress
   });
-  await writeFile5(outFile, result.bytes);
+  await writeFile6(outFile, result.bytes);
   return {
     out: outFile,
     bytes: result.bytes.length,
@@ -3876,9 +4179,9 @@ function proposeTransitions(input, kind) {
   for (const step of steps) {
     if (!step.navigated || step.skipped) continue;
     const name = step.id ?? String(step.step);
-    const wait = step.do === "wait";
-    const outEnd = round3(wait ? step.tStart : step.tEnd);
-    const inStart = round3(wait ? step.tEnd : step.tEnd + STEP_SETTLE_SECONDS);
+    const wait2 = step.do === "wait";
+    const outEnd = round3(wait2 ? step.tStart : step.tEnd);
+    const inStart = round3(wait2 ? step.tEnd : step.tEnd + STEP_SETTLE_SECONDS);
     const segs = doc.segments;
     if (segs.some(
       (s) => !s.media && Math.abs(s.out - outEnd) < 0.05 && s !== segs.at(-1)
@@ -4197,9 +4500,9 @@ function isLightHexGround(hex2) {
 }
 
 // src/plugin/posterDoc.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { readFile as readFile5 } from "fs/promises";
-import { isAbsolute, join as join6, resolve as resolve3 } from "path";
+import { isAbsolute, join as join7, resolve as resolve3 } from "path";
 import {
   computeCardLayout,
   docStillTime as docStillTime2,
@@ -4211,7 +4514,7 @@ import {
 // src/plugin/platform.ts
 import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function platformOrigin(flags = {}) {
   const legacyEnv = process.env.VOS_API_BASE?.trim();
   const raw = flags.origin ?? flags.api ?? process.env.VOS_ORIGIN?.trim() ?? legacyEnv ?? "https://vos.so";
@@ -4244,7 +4547,7 @@ function parseVosId(input) {
 function deriveSlug(title) {
   return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/, "") || "remix";
 }
-var CREDENTIALS_PATH = join5(homedir(), ".config", "vos", "credentials");
+var CREDENTIALS_PATH = join6(homedir(), ".config", "vos", "credentials");
 function resolveCredential(explicit) {
   const flag = explicit?.trim();
   if (flag) return flag;
@@ -4267,7 +4570,7 @@ function requireCredential(explicit) {
   return key;
 }
 function writeCredential(key) {
-  mkdirSync(join5(homedir(), ".config", "vos"), { recursive: true, mode: 448 });
+  mkdirSync(join6(homedir(), ".config", "vos"), { recursive: true, mode: 448 });
   writeFileSync(CREDENTIALS_PATH, `${key.trim()}
 `, { mode: 384 });
   return CREDENTIALS_PATH;
@@ -4311,7 +4614,7 @@ function readJsonFile(file) {
   }
 }
 function readSyncState(dir) {
-  const own = readJsonFile(join5(dir, SYNC_STATE_NAME));
+  const own = readJsonFile(join6(dir, SYNC_STATE_NAME));
   if (own && typeof own.vosId === "string") {
     return {
       vosId: own.vosId,
@@ -4322,7 +4625,7 @@ function readSyncState(dir) {
       ...typeof own.remixOfId === "string" ? { remixOfId: own.remixOfId } : {}
     };
   }
-  const push = readJsonFile(join5(dir, "push.json"));
+  const push = readJsonFile(join6(dir, "push.json"));
   if (push && typeof push.vosId === "string") {
     return {
       vosId: push.vosId,
@@ -4330,7 +4633,7 @@ function readSyncState(dir) {
       ...typeof push.pushedAt === "string" ? { pushedAt: push.pushedAt } : {}
     };
   }
-  const meta = readJsonFile(join5(dir, "meta.json"));
+  const meta = readJsonFile(join6(dir, "meta.json"));
   if (meta && typeof meta.id === "string") {
     return {
       vosId: meta.id,
@@ -4348,7 +4651,7 @@ function writeSyncState(dir, patch) {
     ...patch
   };
   writeFileSync(
-    join5(dir, SYNC_STATE_NAME),
+    join6(dir, SYNC_STATE_NAME),
     `${JSON.stringify(merged, null, 2)}
 `
   );
@@ -4387,9 +4690,9 @@ var roleFor = (cls) => `poster-${cls}`;
 async function readPosterAt(cls, path, takeDir, from) {
   let file = path;
   let docDir = path;
-  if (existsSync5(join6(path, "doc.json"))) {
-    file = join6(path, "doc.json");
-  } else if (!/\.json$/i.test(path) || !existsSync5(path)) {
+  if (existsSync6(join7(path, "doc.json"))) {
+    file = join7(path, "doc.json");
+  } else if (!/\.json$/i.test(path) || !existsSync6(path)) {
     return null;
   } else {
     docDir = resolve3(path, "..");
@@ -4406,7 +4709,7 @@ async function readPosterAt(cls, path, takeDir, from) {
   const doc = migrateHostedDoc(
     raw
   );
-  const ownFootage = existsSync5(join6(docDir, "meta.json")) && existsSync5(join6(docDir, source.videoKey));
+  const ownFootage = existsSync6(join7(docDir, "meta.json")) && existsSync6(join7(docDir, source.videoKey));
   const sync = readSyncState(docDir);
   return {
     cls,
@@ -4429,10 +4732,10 @@ async function findPosterDocs(takeDir, launchRoles) {
       candidates.push({ path: at2(named.trim()), from: `LAUNCH.md ${role}` });
     }
     candidates.push({
-      path: join6(takeDir, "poster", cls),
+      path: join7(takeDir, "poster", cls),
       from: `poster/${cls}`
     });
-    candidates.push({ path: join6(takeDir, "poster"), from: "poster" });
+    candidates.push({ path: join7(takeDir, "poster"), from: "poster" });
     for (const c of candidates) {
       const ref = await readPosterAt(cls, c.path, takeDir, c.from);
       if (ref) {
@@ -4528,18 +4831,18 @@ function resolveChannels(raw) {
   return out;
 }
 async function readBrandBesideTake(dir, explicit) {
-  const candidates = explicit ? [explicit] : [join7(dir, "BRAND.md"), join7(dir, "..", "BRAND.md")];
+  const candidates = explicit ? [explicit] : [join8(dir, "BRAND.md"), join8(dir, "..", "BRAND.md")];
   for (const file of candidates) {
-    if (!existsSync6(file)) continue;
+    if (!existsSync7(file)) continue;
     const roles = parseFrontmatter(await readFile6(file, "utf8"));
     return { file, roles };
   }
   return null;
 }
 async function readLaunchBesideTake(dir, explicit) {
-  const candidates = explicit ? [explicit] : [join7(dir, "LAUNCH.md"), join7(dir, "..", "LAUNCH.md")];
+  const candidates = explicit ? [explicit] : [join8(dir, "LAUNCH.md"), join8(dir, "..", "LAUNCH.md")];
   for (const file of candidates) {
-    if (!existsSync6(file)) continue;
+    if (!existsSync7(file)) continue;
     return { file, roles: parseFrontmatter(await readFile6(file, "utf8")) };
   }
   return null;
@@ -4604,7 +4907,7 @@ async function pickStillTimes(browser, dir, doc, duration, opts) {
   const meta = doc.source.meta;
   const vw = meta.captureWidth ?? meta.width;
   const vh = meta.captureHeight ?? meta.height;
-  const probeDir = await mkdtemp(join7(tmpdir(), "vos-moments-"));
+  const probeDir = await mkdtemp(join8(tmpdir(), "vos-moments-"));
   try {
     const probe = await framesTake(browser, dir, {
       times: candidates.map((c) => c.time),
@@ -4643,7 +4946,7 @@ async function pickStillTimes(browser, dir, doc, duration, opts) {
       notes: [...notes, ...pick.dropped.map((d) => `moment: ${d}`)]
     };
   } finally {
-    await rm3(probeDir, { recursive: true, force: true });
+    await rm4(probeDir, { recursive: true, force: true });
   }
 }
 var overCeiling = (bytes, maxBytes) => `${Math.ceil(bytes / 1024)} KB exceeds the ${Math.floor(maxBytes / 1024)} KB ceiling`;
@@ -4691,8 +4994,8 @@ async function deliverTake(browser, dir, opts) {
   const doc = take.doc;
   const duration = docOutputDuration2(doc);
   const videoSeconds = opts.range ? Math.min(opts.range[1], duration) - Math.min(opts.range[0], duration) : duration;
-  const outDir = resolve4(opts.outDir ?? join7(dir, "kit"));
-  await mkdir4(outDir, { recursive: true });
+  const outDir = resolve4(opts.outDir ?? join8(dir, "kit"));
+  await mkdir5(outDir, { recursive: true });
   const destinations = opts.channels.flatMap((c) => destinationsForChannel(c));
   const assets = [];
   const skipped = [];
@@ -4752,7 +5055,7 @@ async function deliverTake(browser, dir, opts) {
     opts.onPhase?.(
       `${label} (${specWords(d)}) from ${ref.from}${ref.vosId ? ` ${ref.vosId}` : ""}, the rest at ${time.toFixed(2)}s`
     );
-    const shotDir = await mkdtemp(join7(tmpdir(), "vos-poster-"));
+    const shotDir = await mkdtemp(join8(tmpdir(), "vos-poster-"));
     try {
       const captured = await framesTake(browser, ref.takeDir, {
         times: [time],
@@ -4762,9 +5065,9 @@ async function deliverTake(browser, dir, opts) {
         doc: ref.doc,
         overrides: opts.overrides
       });
-      const to = join7(outDir, `${d.id}.png`);
-      await rename4(captured.frames[0].file, to);
-      const bytes = (await stat(to)).size;
+      const to = join8(outDir, `${d.id}.png`);
+      await rename5(captured.frames[0].file, to);
+      const bytes = (await stat2(to)).size;
       if (d.maxBytes !== void 0 && bytes > d.maxBytes) {
         skipped.push(
           `${label}: ${overCeiling(bytes, d.maxBytes)} (kept at ${to})`
@@ -4793,7 +5096,7 @@ async function deliverTake(browser, dir, opts) {
         ...shot.x < 0 && shot.x + shot.w > 1 ? { crop: true } : {}
       });
     } finally {
-      await rm3(shotDir, { recursive: true, force: true });
+      await rm4(shotDir, { recursive: true, force: true });
     }
   }
   if (missing.size) {
@@ -4834,7 +5137,7 @@ async function deliverTake(browser, dir, opts) {
         }
       }
       opts.onPhase?.(`${label} (${specWords(d)})`);
-      const outFile = join7(outDir, `${d.id}.${d.format}`);
+      const outFile = join8(outDir, `${d.id}.${d.format}`);
       const bitrate = d.maxBytes !== void 0 ? Math.min(
         1e7,
         Math.floor(d.maxBytes * 8 / seconds * 0.85)
@@ -4881,9 +5184,9 @@ async function deliverTake(browser, dir, opts) {
     for (let i = 0; i < captured.frames.length; i++) {
       const frame = captured.frames[i];
       const name = captured.frames.length > 1 ? `${d.id}-${i + 1}.png` : `${d.id}.png`;
-      const to = join7(outDir, name);
-      await rename4(frame.file, to);
-      const bytes = (await stat(to)).size;
+      const to = join8(outDir, name);
+      await rename5(frame.file, to);
+      const bytes = (await stat2(to)).size;
       if (d.maxBytes !== void 0 && bytes > d.maxBytes) {
         skipped.push(
           `${label}: ${overCeiling(bytes, d.maxBytes)} (kept at ${to})`
@@ -4919,15 +5222,15 @@ async function deliverTake(browser, dir, opts) {
     skipped,
     assets
   };
-  const kitFile = join7(outDir, "kit.json");
-  await writeFile6(kitFile, JSON.stringify(kit, null, 2));
+  const kitFile = join8(outDir, "kit.json");
+  await writeFile7(kitFile, JSON.stringify(kit, null, 2));
   return { kit, kitFile, outDir };
 }
 
 // src/plugin/markAsset.ts
-import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import { isAbsolute as isAbsolute2, join as join8, resolve as resolve5 } from "path";
+import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { isAbsolute as isAbsolute2, join as join9, resolve as resolve5 } from "path";
 function markExtension(url) {
   const m = /\.(svg|png|webp|jpe?g)(?:[?#]|$)/i.exec(url);
   if (!m) return null;
@@ -5009,7 +5312,7 @@ async function fetchBrandMarks(takeDir, roles) {
         bytes = new Uint8Array(await res.arrayBuffer());
       } else {
         const file = isAbsolute2(src) ? src : resolve5(takeDir, src);
-        if (!existsSync7(file)) throw new Error("no such file");
+        if (!existsSync8(file)) throw new Error("no such file");
         bytes = new Uint8Array(await readFile7(file));
       }
     } catch (e) {
@@ -5025,8 +5328,8 @@ async function fetchBrandMarks(takeDir, roles) {
       );
       return null;
     }
-    await mkdir5(join8(takeDir, "brand"), { recursive: true });
-    await writeFile7(join8(takeDir, "brand", `${name}.${ext}`), bytes);
+    await mkdir6(join9(takeDir, "brand"), { recursive: true });
+    await writeFile8(join9(takeDir, "brand", `${name}.${ext}`), bytes);
     return { key: `/brand/${name}.${ext}`, aspect };
   };
   out.light = await one("logoUrl", "mark");
@@ -5062,9 +5365,9 @@ async function fetchMusicCatalog(origin) {
 }
 
 // src/plugin/judge.ts
-import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
-import { dirname, isAbsolute as isAbsolute3, join as join9, resolve as resolve6 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { mkdir as mkdir7, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join10, resolve as resolve6 } from "path";
 import { DESTINATIONS as DESTINATIONS2 } from "@vosjs/studio-core";
 
 // src/plugin/shotBake.ts
@@ -5147,7 +5450,8 @@ function rolesFor(asset) {
     const portrait = spec.px.w < spec.px.h;
     return portrait ? ["feature-clip", "site-walkthrough"] : ["feature-clip", "site-walkthrough", "feature-clip-dark"];
   }
-  if (spec?.genre === "card") return ["window-in-scene", "card-on-gradient", "framed-screenshot"];
+  if (spec?.genre === "card")
+    return ["window-in-scene", "card-on-gradient", "framed-screenshot"];
   if (spec?.genre === "screenshot") return ["framed-screenshot", "app-session"];
   return [];
 }
@@ -5207,7 +5511,8 @@ function composeSheet(left, right, height = 540, gutter = 32) {
         const si = (y * src.w + x) * 4;
         const a = src.data[si + 3] / 255;
         const o = ((y0 + y) * w + x0 + x) * 4;
-        for (let c = 0; c < 3; c++) out[o + c] = Math.round(src.data[si + c] * a + out[o + c] * (1 - a));
+        for (let c = 0; c < 3; c++)
+          out[o + c] = Math.round(src.data[si + c] * a + out[o + c] * (1 - a));
       }
     }
   };
@@ -5223,51 +5528,70 @@ function composeSheet(left, right, height = 540, gutter = 32) {
       }
   };
   fill(margin, margin + lw, margin + height + 6, margin + height + 6 + band, 40);
-  fill(margin + lw + gutter, margin + lw + gutter + rw, margin + height + 6, margin + height + 6 + band, 200);
+  fill(
+    margin + lw + gutter,
+    margin + lw + gutter + rw,
+    margin + height + 6,
+    margin + height + 6 + band,
+    200
+  );
   return { w, h, data: out };
 }
 async function judgeKit(kitPath, manifestPath, outDir) {
   const kit = JSON.parse(await readFile8(kitPath, "utf8"));
-  const manifest = JSON.parse(await readFile8(manifestPath, "utf8"));
-  const manifestDir = dirname(resolve6(manifestPath));
-  const kitDir = dirname(resolve6(kitPath));
-  const out = resolve6(outDir ?? join9(kitDir, "judge"));
-  await mkdir6(out, { recursive: true });
+  const manifest = JSON.parse(
+    await readFile8(manifestPath, "utf8")
+  );
+  const manifestDir = dirname2(resolve6(manifestPath));
+  const kitDir = dirname2(resolve6(kitPath));
+  const out = resolve6(outDir ?? join10(kitDir, "judge"));
+  await mkdir7(out, { recursive: true });
   const sheets = [];
   const skipped = [];
   const refCache = /* @__PURE__ */ new Map();
   const loadRef = async (file) => {
     if (refCache.has(file)) return refCache.get(file) ?? null;
-    const p = join9(manifestDir, file);
-    const img = existsSync8(p) ? decodePng(new Uint8Array(await readFile8(p))) : null;
+    const p = join10(manifestDir, file);
+    const img = existsSync9(p) ? decodePng(new Uint8Array(await readFile8(p))) : null;
     refCache.set(file, img);
     return img;
   };
   for (const a of kit.assets) {
     if (!/\.png$/i.test(a.path)) continue;
-    const file = isAbsolute3(a.path) && existsSync8(a.path) ? a.path : join9(kitDir, a.path.split("/").pop() ?? a.path);
-    const img = existsSync8(file) ? decodePng(new Uint8Array(await readFile8(file))) : null;
+    const file = isAbsolute3(a.path) && existsSync9(a.path) ? a.path : join10(kitDir, a.path.split("/").pop() ?? a.path);
+    const img = existsSync9(file) ? decodePng(new Uint8Array(await readFile8(file))) : null;
     if (!img) {
       skipped.push(`${a.destination ?? a.path}: unreadable`);
       continue;
     }
-    const roles = rolesFor({ destination: a.destination, source: a.source, template: a.template, path: a.path });
-    const ref = manifest.assets.find((r) => roles.includes(r.role) && r.genre !== "context");
+    const roles = rolesFor({
+      destination: a.destination,
+      source: a.source,
+      template: a.template,
+      path: a.path
+    });
+    const ref = manifest.assets.find(
+      (r) => roles.includes(r.role) && r.genre !== "context"
+    );
     if (!ref) {
-      skipped.push(`${a.destination ?? a.path}: no reference of role ${roles.join("|") || "(none)"}`);
+      skipped.push(
+        `${a.destination ?? a.path}: no reference of role ${roles.join("|") || "(none)"}`
+      );
       continue;
     }
     const refImg = await loadRef(ref.file);
     if (!refImg) {
-      skipped.push(`${a.destination ?? a.path}: reference ${ref.file} unreadable`);
+      skipped.push(
+        `${a.destination ?? a.path}: reference ${ref.file} unreadable`
+      );
       continue;
     }
     const stem = (a.path.split("/").pop() ?? a.path).replace(/\.png$/i, "");
     const id = stem.replace(/[^A-Za-z0-9_-]+/g, "-") || a.destination || "asset";
     const nameA = `${id}--A.png`;
     const nameB = `${id}--B.png`;
-    await writeFile8(join9(out, nameA), encodePng(composeSheet(img, refImg)));
-    await writeFile8(join9(out, nameB), encodePng(composeSheet(refImg, img)));
+    await writeFile9(join10(out, nameA), encodePng(composeSheet(img, refImg)));
+    await writeFile9(join10(out, nameB), encodePng(composeSheet(refImg, img)));
     const rubric = [
       `# ${id} against ${ref.id} (${ref.file})`,
       "",
@@ -5287,18 +5611,31 @@ async function judgeKit(kitPath, manifestPath, outDir) {
       "In judge.json: `win` true when the kit asset is at least as good as the reference on the rules that apply to its genre, false when it is worse, null for a tie; `reasons` names the rules by number.",
       ""
     ].join("\n");
-    await writeFile8(join9(out, `${id}.md`), rubric);
-    sheets.push({ asset: id, reference: ref.id, sheetA: nameA, sheetB: nameB, rubric: `${id}.md` });
+    await writeFile9(join10(out, `${id}.md`), rubric);
+    sheets.push({
+      asset: id,
+      reference: ref.id,
+      sheetA: nameA,
+      sheetB: nameB,
+      rubric: `${id}.md`
+    });
   }
-  const verdictFile = join9(out, "judge.json");
-  if (!existsSync8(verdictFile)) {
-    await writeFile8(
+  const verdictFile = join10(out, "judge.json");
+  if (!existsSync9(verdictFile)) {
+    await writeFile9(
       verdictFile,
       JSON.stringify(
         {
           kit: kitPath,
           manifest: manifestPath,
-          verdicts: sheets.map((s) => ({ asset: s.asset, reference: s.reference, A: null, B: null, win: null, reasons: [] }))
+          verdicts: sheets.map((s) => ({
+            asset: s.asset,
+            reference: s.reference,
+            A: null,
+            B: null,
+            win: null,
+            reasons: []
+          }))
         },
         null,
         2
@@ -5308,17 +5645,24 @@ async function judgeKit(kitPath, manifestPath, outDir) {
   return { sheets, skipped, outDir: out, verdictFile };
 }
 function winRate(verdicts) {
-  const judgedList = verdicts.filter((v) => v.win !== null || (v.reasons?.length ?? 0) > 0);
+  const judgedList = verdicts.filter(
+    (v) => v.win !== null || (v.reasons?.length ?? 0) > 0
+  );
   const wins = judgedList.filter((v) => v.win === true).length;
   const ties = judgedList.filter((v) => v.win === null).length;
   const judged = judgedList.length;
-  return { wins, ties, judged, rate: judged ? (wins + ties / 2) / judged : null };
+  return {
+    wins,
+    ties,
+    judged,
+    rate: judged ? (wins + ties / 2) / judged : null
+  };
 }
 
 // src/plugin/callout.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { readFile as readFile9 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { lerpArray, sample } from "@vosjs/timeline";
 import {
   CALLOUT_DEFAULT_BODY_PX,
@@ -5501,10 +5845,10 @@ async function footageFrames(browser, dir, doc, times, framesTake2) {
   const out = /* @__PURE__ */ new Map();
   if (!times.length) return out;
   const bare = { ...doc, overlays: [] };
-  const outDir = join10(dir, ".ground-check");
+  const outDir = join11(dir, ".ground-check");
   const res = await framesTake2(browser, dir, { times, outDir, doc: bare });
   for (const f of res.frames) {
-    if (!existsSync9(f.file)) continue;
+    if (!existsSync10(f.file)) continue;
     out.set(
       +f.time.toFixed(3),
       decodePng(new Uint8Array(await readFile9(f.file)))
@@ -5885,9 +6229,9 @@ function formatFinding(f) {
 }
 
 // src/plugin/validateKit.ts
-import { existsSync as existsSync10 } from "fs";
-import { readFile as readFile11, stat as stat2 } from "fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute4, join as join11 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { readFile as readFile11, stat as stat3 } from "fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute4, join as join12 } from "path";
 import { DESTINATIONS as DESTINATIONS3 } from "@vosjs/studio-core";
 var PNG_SIG2 = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 function pngDimensions(bytes) {
@@ -5944,10 +6288,10 @@ async function validateKit(kitPath, opts = {}) {
       measured
     };
   }
-  const base = dirname2(kitPath);
+  const base = dirname3(kitPath);
   const resolvePath = (p) => {
-    if (isAbsolute4(p) && existsSync10(p)) return p;
-    const beside = join11(base, p.split("/").pop() ?? p);
+    if (isAbsolute4(p) && existsSync11(p)) return p;
+    const beside = join12(base, p.split("/").pop() ?? p);
     return beside;
   };
   const perDestination = /* @__PURE__ */ new Map();
@@ -5958,7 +6302,7 @@ async function validateKit(kitPath, opts = {}) {
     const file = resolvePath(a.path);
     let bytes;
     try {
-      bytes = (await stat2(file)).size;
+      bytes = (await stat3(file)).size;
     } catch {
       problems.push(`${label}: ${a.path} is missing`);
       continue;
@@ -6083,7 +6427,7 @@ async function validateKit(kitPath, opts = {}) {
 
 // src/plugin/recorder.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // src/plugin/recordingCap.ts
 var HOSTED_RECORDING_CAP_SECONDS = 30 * 60;
@@ -6165,8 +6509,8 @@ async function clockMotion(dur, at2, clock) {
     await at2(easeInOutCubic(Math.min(1, elapsed / dur)));
     samples++;
     const next = start + Math.ceil((clock.now() - start) / MOTION_TICK_MS) * MOTION_TICK_MS;
-    const wait = Math.min(next, start + dur) - clock.now();
-    if (wait > 0) await clock.sleep(wait);
+    const wait2 = Math.min(next, start + dur) - clock.now();
+    if (wait2 > 0) await clock.sleep(wait2);
   }
   await at2(1);
   return samples + 1;
@@ -6176,8 +6520,8 @@ async function clockTyping(chars, delay, type, clock) {
   for (let i = 0; i < chars.length; i++) {
     await type(chars[i], i);
     const due = start + (i + 1) * delay;
-    const wait = due - clock.now();
-    if (wait > 0 && i < chars.length - 1) await clock.sleep(wait);
+    const wait2 = due - clock.now();
+    if (wait2 > 0 && i < chars.length - 1) await clock.sleep(wait2);
   }
 }
 function askedMs(step) {
@@ -6261,7 +6605,7 @@ async function recordTake(browser, url, actions, paths, log, opts = {}) {
   cdp.on("Page.screencastFrame", (ev) => {
     const tsMs = ev.metadata.timestamp ? ev.metadata.timestamp * 1e3 : Date.now();
     const file = `frame-${String(frameIdx++).padStart(5, "0")}.jpg`;
-    writeFileSync2(join12(paths.framesDir, file), Buffer.from(ev.data, "base64"));
+    writeFileSync2(join13(paths.framesDir, file), Buffer.from(ev.data, "base64"));
     frames.push({ file, tMs: Math.max(0, Math.round(tsMs - t0)) });
     cdp.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => {
     });
@@ -6523,7 +6867,7 @@ async function recordTake(browser, url, actions, paths, log, opts = {}) {
   await sleep(200);
   const pageTitle = await page.title().catch(() => "");
   await context.close();
-  const firstFrame = frames[0] ? jpegDims(readFileSync3(join12(paths.framesDir, frames[0].file))) : null;
+  const firstFrame = frames[0] ? jpegDims(readFileSync3(join13(paths.framesDir, frames[0].file))) : null;
   const meta = {
     dpr: 1,
     zoom: 1,
@@ -6634,9 +6978,9 @@ async function encodeRecording(browser, takeDir, onProgress) {
 }
 
 // src/plugin/plan.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import {
   DEFAULT_FRAME_STYLE,
   STYLE_FIELDS,
@@ -6858,8 +7202,8 @@ function retimeCut(prev, newSteps, newDurationMs) {
 // src/plugin/plan.ts
 var overlaps = (a, b) => a.in < b.out && b.in < a.out;
 async function readDigestActivity(dir) {
-  const file = join13(dir, "digest", "digest.json");
-  if (!existsSync11(file)) return null;
+  const file = join14(dir, "digest", "digest.json");
+  if (!existsSync12(file)) return null;
   try {
     const d = JSON.parse(await readFile12(file, "utf8"));
     return Array.isArray(d.activity) && d.activity.every((v) => typeof v === "number") ? d.activity : null;
@@ -6928,11 +7272,11 @@ async function planTake(dir, opts = {}) {
   if (opts.reuse) {
     const prev = migrateMotion2(opts.reuse.doc);
     const artifact = {
-      videoKey: RECORDING_NAME,
+      videoKey: take.paths.recordingName,
       cursor,
       meta
     };
-    doc = projectFromArtifact(artifact, RECORDING_NAME, ingest).doc;
+    doc = projectFromArtifact(artifact, take.paths.recordingName, ingest).doc;
     doc = copyStyle(prev, doc);
     const rt = retimeCut(prev, meta.steps ?? [], meta.durationMs);
     doc.segments = rt.segments;
@@ -7020,11 +7364,11 @@ async function planTake(dir, opts = {}) {
     }
   } else {
     const artifact = {
-      videoKey: RECORDING_NAME,
+      videoKey: take.paths.recordingName,
       cursor,
       meta
     };
-    doc = projectFromArtifact(artifact, RECORDING_NAME, ingest).doc;
+    doc = projectFromArtifact(artifact, take.paths.recordingName, ingest).doc;
     if (opts.style) {
       const applied = applyStyle(opts.style.doc, doc, opts);
       doc = applied.doc;
@@ -7074,207 +7418,11 @@ import { createHash } from "crypto";
 import { existsSync as existsSync13 } from "fs";
 import { readFile as readFile13 } from "fs/promises";
 import { createInterface } from "readline/promises";
-import { basename, join as join16 } from "path";
+import { basename as basename3, join as join16 } from "path";
 import { lowerToComposition as lowerToComposition3, migrateHostedDoc as migrateHostedDoc3 } from "@vosjs/studio-core";
 
-// src/plugin/media.ts
-import { isKeyedOverlay } from "@vosjs/studio-core";
-import { createWriteStream, existsSync as existsSync12 } from "fs";
-import { writeFile as writeFile9 } from "fs/promises";
-import { join as join14 } from "path";
-import { Readable } from "stream";
-import { pipeline } from "stream/promises";
-var MIC_NAME = "mic.webm";
-var CAM_NAME = "cam.webm";
-var KEYS = [
-  { key: "videoKey", file: RECORDING_NAME },
-  { key: "micKey", file: MIC_NAME },
-  { key: "camKey", file: CAM_NAME }
-];
-function isTakeRelativeKey(key) {
-  return !!key && !/^(https?:|blob:|data:|media:|\/\/)/.test(key) && !key.startsWith("/api/");
-}
-var takeRelativeFile = (key) => key.replace(/^\/+/, "");
-function docMediaRefs(doc, keep = isTakeRelativeKey) {
-  const out = [];
-  for (const m of doc.media ?? []) {
-    if (keep(m.videoKey))
-      out.push({
-        where: `media ${m.id}`,
-        key: m.videoKey,
-        set: (next) => {
-          m.videoKey = next;
-        }
-      });
-    const mic = m.micKey;
-    if (mic && keep(mic))
-      out.push({
-        where: `media ${m.id} mic`,
-        key: mic,
-        set: (next) => {
-          m.micKey = next;
-        }
-      });
-    const cam = m.camKey;
-    if (cam && keep(cam))
-      out.push({
-        where: `media ${m.id} cam`,
-        key: cam,
-        set: (next) => {
-          m.camKey = next;
-        }
-      });
-  }
-  for (const clip of doc.overlays ?? []) {
-    if (!isKeyedOverlay(clip) || !keep(clip.key)) continue;
-    out.push({
-      where: `overlay ${clip.id}`,
-      key: clip.key,
-      set: (next) => {
-        clip.key = next;
-      }
-    });
-  }
-  const mark = doc.endCard?.mark;
-  if (mark && keep(mark.key))
-    out.push({
-      where: "end card mark",
-      key: mark.key,
-      set: (next) => {
-        mark.key = next;
-      }
-    });
-  const bg = doc.frame.backgroundMedia;
-  if (bg && keep(bg.key))
-    out.push({
-      where: "background",
-      key: bg.key,
-      set: (next) => {
-        bg.key = next;
-      }
-    });
-  return out;
-}
-function mediaContentType(file) {
-  const ext = (/\.([a-z0-9]+)$/i.exec(file)?.[1] ?? "").toLowerCase();
-  const types = {
-    svg: "image/svg+xml",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    webp: "image/webp",
-    gif: "image/gif",
-    avif: "image/avif",
-    webm: "video/webm",
-    mp4: "video/mp4",
-    mov: "video/quicktime",
-    mp3: "audio/mpeg",
-    wav: "audio/wav",
-    ogg: "audio/ogg",
-    m4a: "audio/mp4"
-  };
-  return types[ext] ?? "application/octet-stream";
-}
-function extensionFor(contentType) {
-  const t = contentType.split(";")[0].trim().toLowerCase();
-  const exts = {
-    "image/svg+xml": ".svg",
-    "image/png": ".png",
-    "image/jpeg": ".jpg",
-    "image/webp": ".webp",
-    "image/gif": ".gif",
-    "image/avif": ".avif",
-    "video/webm": ".webm",
-    "video/mp4": ".mp4",
-    "video/quicktime": ".mov",
-    "audio/mpeg": ".mp3",
-    "audio/wav": ".wav",
-    "audio/ogg": ".ogg",
-    "audio/mp4": ".m4a"
-  };
-  return exts[t] ?? "";
-}
-function assetIdOf(url) {
-  if (!url) return null;
-  const m = /\/api\/assets\/([A-Za-z0-9_-]+)\/file/.exec(url);
-  return m ? m[1] : null;
-}
-async function pullMedia(ctx, dir, doc, log) {
-  const result = { downloaded: [], kept: [] };
-  for (const { key, file } of KEYS) {
-    const url = doc.source[key];
-    const assetId = assetIdOf(url);
-    if (!assetId) continue;
-    const target = join14(dir, file);
-    if (existsSync12(target)) {
-      result.kept.push(file);
-    } else {
-      const abs = /^https?:/.test(url) ? url : `${ctx.origin}${url}`;
-      const res = await fetch(abs, {
-        headers: ctx.key ? { authorization: `Bearer ${ctx.key}` } : {}
-      });
-      if (!res.ok || !res.body) {
-        throw new Error(
-          `download of ${file} failed (${res.status})${res.status === 404 ? " \u2014 a private recording needs a content key of its owner" : ""}`
-        );
-      }
-      await pipeline(
-        Readable.fromWeb(res.body),
-        createWriteStream(target)
-      );
-      const bytes = (await import("fs/promises").then((fs) => fs.stat(target))).size;
-      result.downloaded.push({ file, assetId, bytes });
-      log(`  ${file} \u2190 asset ${assetId} (${Math.round(bytes / 1024)} kB)`);
-    }
-    doc.source[key] = file;
-  }
-  for (const ref of docMediaRefs(doc, (k) => assetIdOf(k) !== null)) {
-    const assetId = assetIdOf(ref.key);
-    const abs = /^https?:/.test(ref.key) ? ref.key : `${ctx.origin}${ref.key}`;
-    const existing = existsSync12(join14(dir, "media")) ? (await import("fs/promises").then(
-      (fs) => fs.readdir(join14(dir, "media"))
-    )).find((f) => f.startsWith(`${assetId}.`)) : void 0;
-    let file;
-    if (existing) {
-      file = `media/${existing}`;
-      result.kept.push(file);
-    } else {
-      const res = await fetch(abs, {
-        headers: ctx.key ? { authorization: `Bearer ${ctx.key}` } : {}
-      });
-      if (!res.ok || !res.body) {
-        throw new Error(
-          `download of ${ref.where} (${ref.key}) failed (${res.status})`
-        );
-      }
-      const ext = extensionFor(res.headers.get("content-type") ?? "");
-      file = `media/${assetId}${ext}`;
-      const target = join14(dir, file);
-      await import("fs/promises").then(
-        (fs) => fs.mkdir(join14(dir, "media"), { recursive: true })
-      );
-      await pipeline(
-        Readable.fromWeb(res.body),
-        createWriteStream(target)
-      );
-      const bytes = (await import("fs/promises").then((fs) => fs.stat(target))).size;
-      result.downloaded.push({ file, assetId, bytes });
-      log(
-        `  ${file} \u2190 ${ref.where}, asset ${assetId} (${Math.round(bytes / 1024)} kB)`
-      );
-    }
-    ref.set(file);
-  }
-  const metaPath = join14(dir, "meta.json");
-  if (!existsSync12(metaPath)) await writeJson(metaPath, doc.source.meta, true);
-  const cursorPath = join14(dir, "cursor.json");
-  if (!existsSync12(cursorPath)) await writeJson(cursorPath, doc.source.cursor);
-  await writeFile9(join14(dir, "doc.json"), JSON.stringify(doc, null, 2));
-  return result;
-}
-
 // src/plugin/folder.ts
-import { mkdir as mkdir7, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir8, writeFile as writeFile10 } from "fs/promises";
 import { join as join15 } from "path";
 import { recipeHints } from "@vosjs/shared/frontmatter";
 import { migrateHostedDoc as migrateHostedDoc2 } from "@vosjs/studio-core";
@@ -7385,7 +7533,7 @@ async function cmdMove(argv) {
   });
   const key = requireCredential(strFlag(flags, "key"));
   const folderId = toRef === "none" ? null : resolveFolder(await listFolders(origin, key), toRef).id;
-  let failed = 0;
+  let failed2 = 0;
   const moved = [];
   for (const raw of positionals) {
     const id = parseVosId(raw);
@@ -7400,28 +7548,28 @@ async function cmdMove(argv) {
       continue;
     }
     if (asVos.status === 404) {
-      const asAsset = await apiJson(origin, `/api/assets/${id}`, {
+      const asAsset2 = await apiJson(origin, `/api/assets/${id}`, {
         method: "PATCH",
         key,
         body: { folderId }
       });
-      if (asAsset.status === 200) {
+      if (asAsset2.status === 200) {
         moved.push({ id, kind: "asset" });
         r.log(`moved asset ${id}`);
         continue;
       }
-      failed++;
-      r.log(apiError(`move ${id}`, asAsset));
+      failed2++;
+      r.log(apiError(`move ${id}`, asAsset2));
       continue;
     }
-    failed++;
+    failed2++;
     r.log(apiError(`move ${id}`, asVos));
   }
   r.done(
-    { moved, failed, folderId },
-    `moved ${moved.length}/${positionals.length} into ${toRef === "none" ? "the top level" : toRef}${failed ? ` \u2014 ${failed} failed` : ""}`
+    { moved, failed: failed2, folderId },
+    `moved ${moved.length}/${positionals.length} into ${toRef === "none" ? "the top level" : toRef}${failed2 ? ` \u2014 ${failed2} failed` : ""}`
   );
-  return failed ? EXIT_ERROR : EXIT_OK;
+  return failed2 ? EXIT_ERROR : EXIT_OK;
 }
 function recipeLine(filename, body) {
   const h = recipeHints(body);
@@ -7451,7 +7599,7 @@ async function cmdPull(argv) {
     throw new Error(apiError(`pull folder ${folder.slug}`, res));
   const payload = res.body;
   const out = strFlag(flags, "out") ?? folder.slug;
-  await mkdir7(join15(out, "recipes"), { recursive: true });
+  await mkdir8(join15(out, "recipes"), { recursive: true });
   const lines = [];
   const recipes = [];
   for (const rec of payload.recipes) {
@@ -7461,7 +7609,7 @@ async function cmdPull(argv) {
   }
   for (const rec of payload.inheritedRecipes) {
     const from = safeName(rec.folderSlug ?? "inherited");
-    await mkdir7(join15(out, "recipes", "_inherited", from), { recursive: true });
+    await mkdir8(join15(out, "recipes", "_inherited", from), { recursive: true });
     const path = join15(
       out,
       "recipes",
@@ -7478,7 +7626,7 @@ async function cmdPull(argv) {
   const members = [];
   for (const v of payload.voses) {
     const dir = join15(out, "members", safeName(v.slug || v.title || v.id));
-    await mkdir7(dir, { recursive: true });
+    await mkdir8(dir, { recursive: true });
     const cfg = await apiJson(origin, `/api/vos/${v.id}/config`, { key });
     if (cfg.status !== 200) {
       lines.push(`skipped ${v.title}: ${apiError("fetch config", cfg)}`);
@@ -7567,6 +7715,144 @@ async function cmdFolder(argv) {
   }
 }
 
+// src/plugin/uploadAsset.ts
+var SINGLE_SHOT_MAX_BYTES = 32 * 1024 * 1024;
+var PART_ATTEMPTS = 3;
+function planParts(totalBytes, partBytes) {
+  if (totalBytes <= 0 || partBytes <= 0) return [];
+  const parts = [];
+  for (let start = 0; start < totalBytes; start += partBytes) {
+    parts.push({
+      partNumber: parts.length + 1,
+      start,
+      end: Math.min(start + partBytes, totalBytes)
+    });
+  }
+  return parts;
+}
+function failed(what, r) {
+  const detail = typeof r.body.error === "string" ? r.body.error : "";
+  return new Error(`${what} (${r.status})${detail ? `: ${detail}` : ""}`);
+}
+function asAsset(body) {
+  return {
+    id: String(body.id),
+    url: String(body.url),
+    size: typeof body.size === "number" ? body.size : 0,
+    reused: body.reused === true
+  };
+}
+function transient(status) {
+  return status >= 500 || status === 429;
+}
+var wait = (ms) => new Promise((r) => setTimeout(r, ms));
+async function uploadAsset(target, bytes, opts) {
+  return bytes.length > SINGLE_SHOT_MAX_BYTES ? uploadInParts(target, bytes, opts) : uploadWhole(target, bytes, opts);
+}
+async function uploadWhole(target, bytes, opts) {
+  const res = await apiJson(target.origin, "/api/assets/recording", {
+    method: "POST",
+    key: target.key,
+    headers: {
+      "Content-Type": opts.contentType,
+      "Content-Length": String(bytes.length),
+      "X-Filename": opts.filename,
+      "X-Content-Hash": opts.contentHash,
+      ...opts.durationSeconds && opts.durationSeconds > 0 ? { "X-Content-Duration": opts.durationSeconds.toFixed(3) } : {}
+    },
+    raw: bytes
+  });
+  if (res.status !== 201 && res.status !== 200)
+    throw failed("upload failed", res);
+  return asAsset(res.body);
+}
+async function uploadInParts(target, bytes, opts) {
+  const begun = await apiJson(
+    target.origin,
+    "/api/assets/recording/multipart",
+    {
+      method: "POST",
+      key: target.key,
+      body: {
+        filename: opts.filename,
+        contentType: opts.contentType,
+        size: bytes.length,
+        contentHash: opts.contentHash,
+        ...opts.durationSeconds && opts.durationSeconds > 0 ? { durationSeconds: opts.durationSeconds } : {}
+      }
+    }
+  );
+  if (begun.status !== 201 && begun.status !== 200) {
+    throw failed("upload failed", begun);
+  }
+  if (begun.body.reused === true || typeof begun.body.url === "string") {
+    return asAsset(begun.body);
+  }
+  const uploadId = String(begun.body.id);
+  const partBytes = Number(begun.body.partBytes);
+  if (!Number.isFinite(partBytes) || partBytes <= 0) {
+    throw new Error("upload failed: the platform returned no part size");
+  }
+  const parts = planParts(bytes.length, partBytes);
+  const etags = [];
+  try {
+    for (const part of parts) {
+      const chunk2 = bytes.subarray(part.start, part.end);
+      let sent = null;
+      for (let attempt = 1; attempt <= PART_ATTEMPTS; attempt++) {
+        try {
+          sent = await apiJson(
+            target.origin,
+            `/api/assets/recording/multipart/${uploadId}/parts/${part.partNumber}`,
+            {
+              method: "PUT",
+              key: target.key,
+              headers: {
+                "Content-Type": "application/octet-stream",
+                "Content-Length": String(chunk2.length)
+              },
+              raw: chunk2
+            }
+          );
+        } catch (networkError) {
+          if (attempt === PART_ATTEMPTS) throw networkError;
+          await wait(500 * 2 ** (attempt - 1));
+          continue;
+        }
+        if (sent.status === 200) break;
+        if (!transient(sent.status) || attempt === PART_ATTEMPTS) {
+          throw failed(`part ${part.partNumber} failed`, sent);
+        }
+        await wait(500 * 2 ** (attempt - 1));
+      }
+      if (!sent || sent.status !== 200) {
+        throw new Error(`part ${part.partNumber} failed`);
+      }
+      etags.push({
+        partNumber: Number(sent.body.partNumber),
+        etag: String(sent.body.etag)
+      });
+      opts.onPart?.(etags.length, parts.length);
+    }
+    const sealed = await apiJson(
+      target.origin,
+      `/api/assets/recording/multipart/${uploadId}/complete`,
+      { method: "POST", key: target.key, body: { parts: etags } }
+    );
+    if (sealed.status !== 201 && sealed.status !== 200) {
+      throw failed("upload failed", sealed);
+    }
+    return asAsset(sealed.body);
+  } catch (err) {
+    await apiJson(
+      target.origin,
+      `/api/assets/recording/multipart/${uploadId}`,
+      { method: "DELETE", key: target.key }
+    ).catch(() => void 0);
+    throw err;
+  }
+}
+
 // src/plugin/sync.ts
 function apiContext(flags) {
   return {
@@ -7615,7 +7901,9 @@ async function pushTake(dir, flags, r) {
   ${lint.problems.join("\n  ")}`);
   }
   if (!existsSync13(take.paths.recording)) {
-    throw new Error("no recording.webm in this take");
+    throw new Error(
+      "no recording in this take \u2014 record it, or `vos pull --media` to bring it home"
+    );
   }
   const ctx = apiContext(flags);
   const state = readSyncState(dir);
@@ -7648,32 +7936,36 @@ async function pushTake(dir, flags, r) {
   }
   const bytes = await readFile13(take.paths.recording);
   const hash = createHash("sha256").update(bytes).digest("hex");
+  const { type: contentType } = resolveMediaType({
+    head: bytes.subarray(0, MEDIA_HEAD_BYTES),
+    filename: take.paths.recordingName
+  });
+  const filename = nameForType(take.paths.recordingName, contentType);
+  if (filename !== take.paths.recordingName) {
+    r.log(
+      `  ${take.paths.recordingName} holds ${contentType} \u2014 uploading it as ${filename}`
+    );
+  }
   r.log(`uploading recording (${Math.round(bytes.length / 1024)} kB)\u2026`);
-  const upload = await api(ctx, "/assets/recording", {
-    method: "POST",
-    headers: {
-      "Content-Type": "video/webm",
-      "Content-Length": String(bytes.length),
-      "X-Filename": RECORDING_NAME,
-      "X-Content-Hash": hash,
+  let upload;
+  try {
+    upload = await uploadAsset(ctx, new Uint8Array(bytes), {
+      filename,
+      contentType,
+      contentHash: hash,
       // The take's length so the server holds it to the plan's cap.
-      ...take.meta.durationMs > 0 ? { "X-Content-Duration": (take.meta.durationMs / 1e3).toFixed(3) } : {}
-    },
-    raw: new Uint8Array(bytes)
-  });
-  if (upload.status !== 201 && upload.status !== 200) {
+      ...take.meta.durationMs > 0 ? { durationSeconds: take.meta.durationMs / 1e3 } : {},
+      onPart: (done, total) => r.log(`  part ${done}/${total}`)
+    });
+  } catch (e) {
     throw new Error(
-      `recording upload failed (${upload.status}): ${String(upload.json.error ?? "")}`
+      `recording upload failed: ${e instanceof Error ? e.message : String(e)}`
     );
   }
-  const assetId = String(upload.json.id);
-  const assetUrl = String(upload.json.url);
-  r.event({
-    event: "recording",
-    assetId,
-    reused: upload.json.reused === true
-  });
-  if (upload.json.reused === true) r.log("  recording already hosted \u2014 reused");
+  const assetId = upload.id;
+  const assetUrl = upload.url;
+  r.event({ event: "recording", assetId, reused: upload.reused });
+  if (upload.reused) r.log("  recording already hosted \u2014 reused");
   const docForPush = structuredClone(take.doc);
   docForPush.source.videoKey = assetUrl;
   if (docForPush.source.camKey && !/^(https?:)?\//.test(docForPush.source.camKey)) {
@@ -7692,31 +7984,35 @@ async function pushTake(dir, flags, r) {
     }
     const media = await readFile13(file);
     const mediaHash = createHash("sha256").update(media).digest("hex");
-    const type = mediaContentType(file);
-    const put = await api(ctx, "/assets/recording", {
-      method: "POST",
-      headers: {
-        "Content-Type": type,
-        "Content-Length": String(media.length),
-        "X-Filename": basename(file),
-        "X-Content-Hash": mediaHash
-      },
-      raw: new Uint8Array(media)
+    const { type } = resolveMediaType({
+      head: media.subarray(0, MEDIA_HEAD_BYTES),
+      filename: file
     });
-    if (put.status !== 201 && put.status !== 200) {
+    const name = nameForType(basename3(file), type);
+    if (name !== basename3(file)) {
+      r.log(`  ${ref.where}: ${basename3(file)} holds ${type} \u2014 sent as ${name}`);
+    }
+    let put;
+    try {
+      put = await uploadAsset(ctx, new Uint8Array(media), {
+        filename: name,
+        contentType: type,
+        contentHash: mediaHash
+      });
+    } catch (e) {
       throw new Error(
-        `${ref.where} upload failed (${put.status}): ${String(put.json.error ?? "")}`
+        `${ref.where} upload failed: ${e instanceof Error ? e.message : String(e)}`
       );
     }
-    ref.set(String(put.json.url));
+    ref.set(put.url);
     r.log(
-      `  ${ref.where}: ${ref.key} \u2192 asset ${String(put.json.id)}${put.json.reused === true ? " (reused)" : ""}`
+      `  ${ref.where}: ${ref.key} \u2192 asset ${put.id}${put.reused ? " (reused)" : ""}`
     );
   }
   const lowered = lowerToComposition3(docForPush);
   const config = { ...lowered.config, data: lowered.data };
   if (!state) {
-    const title = flags.title ?? `Take ${basename(dir)} ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
+    const title = flags.title ?? `Take ${basename3(dir)} ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`;
     const slug = `${title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "take"}-${Date.now().toString(36)}`;
     const created = await api(ctx, "/vos", {
       method: "POST",
@@ -7888,8 +8184,9 @@ async function pullTake(dir, flags, r) {
   }
   const hostedDoc = migrateHostedDoc3(docRes.json);
   const doc = hostedDoc;
-  if (existsSync13(join16(dir, RECORDING_NAME))) {
-    doc.source.videoKey = RECORDING_NAME;
+  const localRecording = takeMediaFile(dir, "recording", RECORDING_NAME);
+  if (existsSync13(localRecording)) {
+    doc.source.videoKey = basename3(localRecording);
   }
   await writeJson(join16(dir, "doc.json"), doc, true);
   const media = flags.media ? await pullMedia(ctx, dir, doc, r.log) : void 0;
@@ -7911,9 +8208,9 @@ async function pullTake(dir, flags, r) {
 
 // src/plugin/program.ts
 import { existsSync as existsSync14 } from "fs";
-import { mkdir as mkdir8, readFile as readFile14, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir9, readFile as readFile14, writeFile as writeFile11 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline/promises";
-import { basename as basename2, dirname as dirname3, join as join17 } from "path";
+import { basename as basename4, dirname as dirname4, join as join17 } from "path";
 import {
   CURRENT_CONFIG_VERSION,
   migrateConfig,
@@ -8110,7 +8407,7 @@ async function cmdFetch(argv) {
     throw new Error(apiError(`fetch config for ${vosId}`, cfg));
   const slug = typeof vosMeta.slug === "string" && vosMeta.slug ? vosMeta.slug : vosId;
   const out = strFlag(flags, "out") ?? slug;
-  await mkdir8(out, { recursive: true });
+  await mkdir9(out, { recursive: true });
   await writeFile11(
     join17(out, "config.json"),
     JSON.stringify(cfg.body.config, null, 2)
@@ -8254,7 +8551,7 @@ async function cmdPushProgram(argv) {
     origin: strFlag(flags, "origin"),
     api: strFlag(flags, "api")
   });
-  const dir = dirname3(source);
+  const dir = dirname4(source);
   const parsed = JSON.parse(await readFile14(source, "utf8"));
   const pre = preflightConfig(parsed);
   if (!pre.ok || !pre.config) {
@@ -8282,7 +8579,7 @@ async function cmdPushProgram(argv) {
         "--claimable creates a NEW claimable vos and cannot iterate (--vos). After the human claims it, iterate with their key: vos push --vos <id>"
       );
     }
-    const fallback = state?.title ? `${state.title} remix` : basename2(source).replace(/\.json$/i, "") || "vos program";
+    const fallback = state?.title ? `${state.title} remix` : basename4(source).replace(/\.json$/i, "") || "vos program";
     const title2 = (strFlag(flags, "title") ?? fallback).slice(0, 100);
     const body = { title: title2, config };
     const slug = strFlag(flags, "slug");
@@ -8380,7 +8677,7 @@ with their key: vos push ${source} --vos ${String(created2.id ?? "<id>")}`
     return EXIT_OK;
   }
   const remixOfId = strFlag(flags, "remix-of") ?? state?.vosId;
-  const fallbackTitle = state?.title ? `${state.title} remix` : basename2(source).replace(/\.json$/i, "") || "vos remix";
+  const fallbackTitle = state?.title ? `${state.title} remix` : basename4(source).replace(/\.json$/i, "") || "vos remix";
   const title = (strFlag(flags, "title") ?? fallbackTitle).slice(0, 100);
   const folderId = folderRef ? resolveFolder(await listFolders(origin, key), folderRef).id : void 0;
   const created = await createProgramVos({
@@ -8432,7 +8729,7 @@ Iterate with: vos push ${source} --vos ${created.id}`
 async function cmdPullProgram(argv) {
   const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS2);
   const target = positionals[0] ?? ".";
-  const dir = target.endsWith(".json") ? dirname3(target) : target;
+  const dir = target.endsWith(".json") ? dirname4(target) : target;
   const r = createReporter(flags.json === true);
   const origin = platformOrigin({
     origin: strFlag(flags, "origin"),
@@ -8615,7 +8912,7 @@ async function writeProgramDoc(dir, hosted) {
 
 // src/plugin/asset.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { basename as basename3, extname as extname2 } from "path";
+import { basename as basename5, extname as extname2 } from "path";
 var BOOLEAN_FLAGS3 = /* @__PURE__ */ new Set(["json", "help"]);
 var MIME_BY_EXT = {
   ".png": "image/png",
@@ -8666,7 +8963,7 @@ async function cmdPush(argv) {
   const folder = folderRef ? resolveFolder(await listFolders(origin, key), folderRef) : null;
   const uploaded = [];
   for (const file of positionals) {
-    const name = basename3(file);
+    const name = basename5(file);
     const mime = MIME_BY_EXT[extname2(name).toLowerCase()] ?? "application/octet-stream";
     const body = readFileSync4(file);
     const form = new FormData();
@@ -8723,11 +9020,11 @@ async function cmdAsset(argv) {
 
 // src/plugin/recipe.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { basename as basename4 } from "path";
+import { basename as basename6 } from "path";
 var BOOLEAN_FLAGS4 = /* @__PURE__ */ new Set(["json", "help"]);
 var USAGE = "vos recipe push <file.md> (--folder <folderId|slug> | --asset <assetId>)";
 function recipeFilename(file) {
-  const name = basename4(file);
+  const name = basename6(file);
   if (!/\.md$/i.test(name)) {
     throw new UsageError(`a recipe is a markdown file \u2014 ${name} is not .md`);
   }
@@ -10033,7 +10330,7 @@ async function cmdRecord(argv) {
       `note: re-recording ${outDir} \u2014 kept ${kept.length ? kept.join(", ") : "nothing"}` + (prevDoc ? "; apply the previous cut to the new footage with: vos plan " + outDir + " --reuse" : "")
     );
   }
-  await mkdir9(outDir, { recursive: true });
+  await mkdir10(outDir, { recursive: true });
   const paths = await ensureTakeDir(outDir);
   const browser = await launchBrowser();
   try {
@@ -10117,7 +10414,7 @@ async function cmdCreate2(argv) {
       `note: re-recording ${outDir} \u2014 kept ${kept.length ? kept.join(", ") : "nothing"}` + (prevDoc ? "; apply the previous cut to the new footage with: vos plan " + outDir + " --reuse" : "")
     );
   }
-  await mkdir9(outDir, { recursive: true });
+  await mkdir10(outDir, { recursive: true });
   const paths = await ensureTakeDir(outDir);
   const browser = await launchBrowser();
   try {
@@ -10202,7 +10499,7 @@ async function cmdPlan(argv) {
     );
   const r = createReporter(flags.json === true);
   if (flags.fresh === true) {
-    await rm4(join18(dir, "doc.json"), { force: true });
+    await rm5(join18(dir, "doc.json"), { force: true });
     r.log("note: --fresh discarded the existing doc.json");
   }
   let reuse;
@@ -10766,7 +11063,7 @@ async function cmdOpen(argv) {
   const r = createReporter(flags.json === true);
   const take = await loadTake(dir);
   if (!existsSync15(take.paths.recording)) {
-    throw new UsageError(`${dir} has no recording.webm \u2014 re-run record`);
+    throw new UsageError(`${dir} has no recording \u2014 re-run record`);
   }
   const studio = (strFlag(flags, "studio") ?? "http://localhost:6060").replace(
     /\/+$/,
@@ -11003,8 +11300,15 @@ async function cmdValidate(argv) {
   const take = await loadTake(target);
   const problems = [];
   const warnings = [];
-  if (!existsSync15(take.paths.recording))
-    problems.push("missing recording.webm (re-run record)");
+  if (!existsSync15(take.paths.recording)) {
+    problems.push("missing recording (re-run record)");
+  } else {
+    const mismatch = containerMismatch(
+      take.paths.recordingName,
+      await readMediaHead(take.paths.recording)
+    );
+    if (mismatch) warnings.push(mismatch);
+  }
   if (!take.doc) problems.push("missing doc.json (run plan)");
   if (take.doc) {
     const lint = lintDoc(take.doc);
@@ -11224,6 +11528,7 @@ export {
   RECORDING_NAME,
   takePaths,
   loadTake,
+  pullMedia,
   startTakeServer,
   waitForPageDone,
   renderAnimation,
@@ -11240,10 +11545,9 @@ export {
   recordTake,
   encodeRecording,
   planTake,
-  pullMedia,
   parseAgentBrowserLog,
   splitCommand,
   convertAgentBrowser,
   run
 };
-//# sourceMappingURL=chunk-VQXOM2NU.js.map
+//# sourceMappingURL=chunk-DD6OXVFJ.js.map