@vosjs/cli 0.69.1 → 0.70.0

package/dist/{chunk-NHJRD2XC.js → chunk-KIFXVPBR.js}

@@ -131,9 +131,9 @@ function landedLines(l) {
 }
 
 // src/plugin/run.ts
-import { mkdir as mkdir8, readFile as readFile12, rm as rm2 } from "fs/promises";
-import { existsSync as existsSync22 } from "fs";
-import { join as join24, resolve as resolve13 } from "path";
+import { mkdir as mkdir8, readFile as readFile13, rm as rm2 } from "fs/promises";
+import { existsSync as existsSync23 } from "fs";
+import { join as join25, resolve as resolve13 } from "path";
 import {
   END_CARD_FROM as END_CARD_FROM2,
   docOutputDuration as docOutputDuration3,
@@ -5341,8 +5341,12 @@ import {
 } from "@vosjs/studio-core";
 
 // src/plugin/reuse.ts
-import { docFreezes } from "@vosjs/studio-core";
+import { docFreezes, ratedSegments as ratedSegments6 } from "@vosjs/studio-core";
 var MIN_SPAN = 0.15;
+var AFTER_STEP = 1;
+var LAYER_AFTER_STEP = 5;
+var WINDOW_SLACK = 0.05;
+var LAYER_DRIFT = 0.5;
 function matchStep(old, newSteps) {
   const usable = (s) => !!s && s.skipped !== true;
   if (old.id) {
@@ -5358,6 +5362,19 @@ function matchStep(old, newSteps) {
   );
   return old.selector !== void 0 && bySignature.length === 1 ? bySignature[0] : usable(atIndex) && old.selector === void 0 && atIndex.do === old.do ? atIndex : null;
 }
+function stepByRef(steps, ref) {
+  return typeof ref === "string" ? steps.find((s) => s.id === ref) : steps.find((s) => s.step === ref);
+}
+var stepName = (s) => String(s.id ?? s.step);
+function stepUnder(t, steps, after = AFTER_STEP) {
+  const gestures = steps.filter((s) => s.do !== "wait" && !s.skipped);
+  const holding = gestures.find(
+    (s) => s.tStart - WINDOW_SLACK <= t && t <= s.tEnd + WINDOW_SLACK
+  );
+  if (holding) return holding;
+  const before = gestures.filter((s) => s.tEnd <= t && t - s.tEnd <= after).sort((a, b) => b.tEnd - a.tEnd);
+  return before[0] ?? null;
+}
 function buildStepMap(oldSteps, newSteps, oldDuration, newDuration) {
   const points = [
     { from: 0, to: 0 },
@@ -5401,34 +5418,57 @@ function buildStepMap(oldSteps, newSteps, oldDuration, newDuration) {
   return { map, unmatched, matched };
 }
 function resolveAnchor2(anchor, newSteps) {
-  const step = typeof anchor.step === "string" ? newSteps.find((s) => s.id === anchor.step) : newSteps.find((s) => s.step === anchor.step);
+  const step = stepByRef(newSteps, anchor.step);
   if (!step || step.skipped) return null;
   const base = anchor.at === "end" ? step.tEnd : step.tStart;
   return base + (anchor.offset ?? 0);
 }
-function retimeSpans(kind, spans, stepMap, newSteps, newDuration, report) {
+function framed(span) {
+  const s = span;
+  if (typeof s.level === "number" && typeof s.cx === "number") {
+    return ` (it framed ${s.cx.toFixed(2)}, ${(s.cy ?? 0).toFixed(2)} at ${s.level.toFixed(1)}\xD7)`;
+  }
+  if (typeof s.rate === "number") return ` (${s.rate}\xD7 speed)`;
+  if (typeof s.rx === "number" || typeof s.ry === "number") {
+    return ` (lean ${s.rx ?? 0}\xB0, ${s.ry ?? 0}\xB0)`;
+  }
+  if (typeof s.seconds === "number") return ` (a ${s.seconds} s hold)`;
+  return "";
+}
+function placeMoment(t, anchor, ctx) {
+  if (anchor) {
+    const at2 = resolveAnchor2(anchor, ctx.newSteps);
+    if (at2 === null) return { gone: String(anchor.step) };
+    ctx.report.anchored++;
+    return { at: at2, via: "anchor" };
+  }
+  const under = stepUnder(t, ctx.oldSteps);
+  if (under) {
+    const hit = matchStep(under, ctx.newSteps);
+    if (!hit) return { gone: under };
+    ctx.report.anchored++;
+    return { at: hit.tStart + (t - under.tStart), via: "step" };
+  }
+  ctx.report.mapped++;
+  return { at: ctx.stepMap.map(t), via: "map" };
+}
+var goneWords = (gone) => typeof gone === "string" ? `its anchored step (${gone}) is missing or skipped in the new recording` : `it sat on step ${stepName(gone)} (${gone.do}${gone.selector ? ` ${gone.selector}` : ""}), which is missing or skipped in the new recording`;
+function retimeSpans(kind, spans, ctx, opts = { overlap: "trim" }) {
   const out = [];
   for (const span of spans) {
     const length = span.out - span.in;
-    let nextIn = null;
-    if (span.anchor) {
-      nextIn = resolveAnchor2(span.anchor, newSteps);
-      if (nextIn === null) {
-        report.flagged.push(
-          `${kind} ${span.id}: its anchored step (${String(span.anchor.step)}) is missing or skipped in the new recording \u2014 fell back to the step map`
-        );
-      } else {
-        report.anchored++;
-      }
-    }
-    if (nextIn === null) {
-      nextIn = stepMap.map(span.in);
-      report.mapped++;
+    const placed = placeMoment(span.in, span.anchor, ctx);
+    if ("gone" in placed) {
+      ctx.report.flagged.push(
+        `${kind} ${span.id}: ${goneWords(placed.gone)} \u2014 dropped; re-aim it on the new footage${framed(span)}`
+      );
+      continue;
     }
-    const nextOut = Math.min(nextIn + length, newDuration);
-    const clampedIn = Math.max(0, Math.min(nextIn, newDuration));
+    const nextIn = placed.at;
+    const nextOut = Math.min(nextIn + length, ctx.newDuration);
+    const clampedIn = Math.max(0, Math.min(nextIn, ctx.newDuration));
     if (nextOut - clampedIn < MIN_SPAN) {
-      report.flagged.push(
+      ctx.report.flagged.push(
         `${kind} ${span.id}: lands outside the new recording (${clampedIn.toFixed(2)}s) \u2014 dropped`
       );
       continue;
@@ -5436,18 +5476,19 @@ function retimeSpans(kind, spans, stepMap, newSteps, newDuration, report) {
     out.push({ ...span, in: +clampedIn.toFixed(3), out: +nextOut.toFixed(3) });
   }
   out.sort((a, b) => a.in - b.in);
+  if (opts.overlap === "keep") return out;
   const kept = [];
   for (const span of out) {
     const prev = kept.at(-1);
     if (prev && span.in < prev.out) {
       const trimmed = { ...span, in: +prev.out.toFixed(3) };
       if (trimmed.out - trimmed.in < MIN_SPAN) {
-        report.flagged.push(
+        ctx.report.flagged.push(
           `${kind} ${span.id}: fully overlapped ${prev.id} after re-timing \u2014 dropped`
         );
         continue;
       }
-      report.flagged.push(
+      ctx.report.flagged.push(
         `${kind} ${span.id}: overlapped ${prev.id} after re-timing \u2014 trimmed to ${trimmed.in.toFixed(2)}s`
       );
       kept.push(trimmed);
@@ -5466,9 +5507,10 @@ function retimeCut(prev, newSteps, newDurationMs) {
   for (const miss of stepMap.unmatched) {
     if (miss.do === "wait") continue;
     report.flagged.push(
-      `step ${miss.id ?? miss.step} (${miss.do}${miss.selector ? ` ${miss.selector}` : ""}) has no match in the new recording \u2014 times near it interpolate`
+      `step ${stepName(miss)} (${miss.do}${miss.selector ? ` ${miss.selector}` : ""}) has no match in the new recording \u2014 times near it interpolate`
     );
   }
+  const ctx = { oldSteps, newSteps, stepMap, newDuration, report };
   const untrimmed = prev.segments.length === 0 || prev.segments.length === 1 && prev.segments[0].in <= 0.05 && prev.segments[0].out >= oldDuration - 0.05;
   const segments = untrimmed ? [{ in: 0, out: +newDuration.toFixed(3) }] : prev.segments.map((s) => ({
     in: +stepMap.map(s.in).toFixed(3),
@@ -5482,49 +5524,34 @@ function retimeCut(prev, newSteps, newDurationMs) {
   const zoom = retimeSpans(
     "zoom",
     prev.zoom.filter((z) => z.source === "manual"),
-    stepMap,
-    newSteps,
-    newDuration,
-    report
+    ctx
   );
   const speed = retimeSpans(
     "speed",
     (prev.speed ?? []).filter((s) => s.source !== "auto"),
-    stepMap,
-    newSteps,
-    newDuration,
-    report
+    ctx
   );
   const tilt = retimeSpans(
     "tilt",
     (prev.tilt ?? []).filter((t) => t.source !== "auto"),
-    stepMap,
-    newSteps,
-    newDuration,
-    report
+    ctx
   );
   const freeze = [];
   for (const f of docFreezes(prev)) {
-    let at2 = null;
-    if (f.anchor) {
-      at2 = resolveAnchor2(f.anchor, newSteps);
-      if (at2 === null) {
-        report.flagged.push(
-          `freeze ${f.id}: its anchored step (${String(f.anchor.step)}) is missing or skipped in the new recording \u2014 fell back to the step map`
-        );
-      } else report.anchored++;
-    }
-    if (at2 === null) {
-      at2 = stepMap.map(f.at);
-      report.mapped++;
+    const placed = placeMoment(f.at, f.anchor, ctx);
+    if ("gone" in placed) {
+      report.flagged.push(
+        `freeze ${f.id}: ${goneWords(placed.gone)} \u2014 dropped; re-place it on the new footage${framed(f)}`
+      );
+      continue;
     }
-    if (at2 < 0 || at2 > newDuration) {
+    if (placed.at < 0 || placed.at > newDuration) {
       report.flagged.push(
-        `freeze ${f.id}: lands outside the new recording (${at2.toFixed(2)}s) \u2014 dropped`
+        `freeze ${f.id}: lands outside the new recording (${placed.at.toFixed(2)}s) \u2014 dropped`
       );
       continue;
     }
-    freeze.push({ ...f, at: +at2.toFixed(3) });
+    freeze.push({ ...f, at: +placed.at.toFixed(3) });
   }
   freeze.sort((a, b) => a.at - b.at);
   const rejected = [];
@@ -5533,15 +5560,97 @@ function retimeCut(prev, newSteps, newDurationMs) {
       ...retimeSpans(
         `rejected ${lane}`,
         (prev.rejected ?? []).filter((r) => r.lane === lane),
-        stepMap,
-        newSteps,
-        newDuration,
-        report
+        ctx,
+        { overlap: "keep" }
       )
     );
   }
   return { segments, zoom, speed, freeze, tilt, rejected, report };
 }
+function sourceToOutput(pieces, s) {
+  let acc = 0;
+  for (const p of pieces) {
+    const rate = p.rate && p.rate > 0 ? p.rate : 1;
+    const len = Math.max(0, p.out - p.in) / rate;
+    if (s < p.in) return acc;
+    if (s <= p.out) return acc + (s - p.in) / rate;
+    acc += len;
+  }
+  return acc;
+}
+function outputToSource(pieces, t) {
+  let acc = 0;
+  for (const p of pieces) {
+    const rate = p.rate && p.rate > 0 ? p.rate : 1;
+    const len = Math.max(0, p.out - p.in) / rate;
+    if (acc + len >= t) return p.in + Math.max(0, t - acc) * rate;
+    acc += len;
+  }
+  return pieces.at(-1)?.out ?? t;
+}
+function retimeOverlays(prev, next, report) {
+  const overlays = prev.overlays ?? [];
+  if (!overlays.length) return [];
+  const oldSteps = prev.source.meta.steps ?? [];
+  const newSteps = next.source.meta.steps ?? [];
+  const oldPieces = ratedSegments6(prev);
+  const newPieces = ratedSegments6(next);
+  const oldDuration = prev.source.meta.durationMs / 1e3;
+  const newDuration = next.source.meta.durationMs / 1e3;
+  const stepMap = buildStepMap(oldSteps, newSteps, oldDuration, newDuration);
+  const ctx = { oldSteps, newSteps, stepMap, report };
+  const follow = (o, oldRef, newRef) => {
+    const offset = o.start - sourceToOutput(oldPieces, oldRef);
+    const start = Math.max(0, sourceToOutput(newPieces, newRef) + offset);
+    return { ...o, start: +start.toFixed(3) };
+  };
+  return overlays.map((o) => {
+    const pin = o.pin;
+    if (pin?.step !== void 0) {
+      const was = stepByRef(oldSteps, pin.step);
+      const now2 = was ? matchStep(was, newSteps) : stepByRef(newSteps, pin.step);
+      if (!now2 || now2.skipped) {
+        report.flagged.push(
+          `overlay ${o.id}: pinned to step ${String(pin.step)}, which is missing or skipped in the new recording \u2014 kept at ${o.start.toFixed(2)}s; re-pin or re-place it`
+        );
+        return o;
+      }
+      report.anchored++;
+      return follow(o, was?.tStart ?? now2.tStart, now2.tStart);
+    }
+    if (typeof pin?.press === "number") {
+      const placed = placeMoment(pin.press, void 0, ctx);
+      if ("gone" in placed) {
+        report.flagged.push(
+          `overlay ${o.id}: pinned to a press at ${pin.press.toFixed(2)}s, and ${goneWords(placed.gone)} \u2014 kept at ${o.start.toFixed(2)}s; re-pin or re-place it`
+        );
+        return o;
+      }
+      const moved = follow(o, pin.press, placed.at);
+      return { ...moved, pin: { ...pin, press: +placed.at.toFixed(3) } };
+    }
+    const under = stepUnder(
+      outputToSource(oldPieces, o.start),
+      oldSteps,
+      LAYER_AFTER_STEP
+    );
+    if (!under) return o;
+    const now = matchStep(under, newSteps);
+    if (!now) {
+      report.flagged.push(
+        `overlay ${o.id} (${o.start.toFixed(2)}s): it sat over step ${stepName(under)}, which is missing or skipped in the new recording \u2014 kept at its output time; re-place it`
+      );
+      return o;
+    }
+    const expected = follow(o, under.tStart, now.tStart).start;
+    if (Math.abs(expected - o.start) > LAYER_DRIFT) {
+      report.flagged.push(
+        `overlay ${o.id} (${o.start.toFixed(2)}s): it sat over step ${stepName(under)}, which now plays at ${expected.toFixed(2)}s in the cut \u2014 kept at ${o.start.toFixed(2)}s by the output-time contract; pin it to follow (pin: { step: ${JSON.stringify(under.id ?? under.step)} }) or move it`
+      );
+    }
+    return o;
+  });
+}
 
 // src/plugin/plan.ts
 var overlaps = (a, b) => a.in < b.out && b.in < a.out;
@@ -5655,7 +5764,9 @@ async function planTake(dir, opts = {}) {
       ].sort((a, b) => a.in - b.in);
     }
     if (rt.tilt.length) doc.tilt = rt.tilt;
-    if (prev.overlays?.length) doc.overlays = prev.overlays;
+    if (prev.overlays?.length) {
+      doc.overlays = retimeOverlays(prev, doc, rt.report);
+    }
     if (prev.objects?.length) doc.objects = prev.objects;
     if (prev.audio.length) doc.audio = prev.audio;
     if (prev.camMotion?.length) doc.camMotion = prev.camMotion;
@@ -5763,15 +5874,48 @@ async function planTake(dir, opts = {}) {
 
 // src/plugin/sync.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
+import { existsSync as existsSync11, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { readFile as readFile10 } from "fs/promises";
 import { createInterface } from "readline/promises";
-import { basename, join as join12 } from "path";
+import { basename, join as join13 } from "path";
 import { lowerToComposition as lowerToComposition3, migrateHostedDoc as migrateHostedDoc2 } from "@vosjs/studio-core";
 
-// src/plugin/folder.ts
-import { mkdir as mkdir5, writeFile as writeFile7 } from "fs/promises";
+// src/plugin/takeScript.ts
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile9, writeFile as writeFile7 } from "fs/promises";
+import { readFileSync as readFileSync2 } from "fs";
 import { join as join11 } from "path";
+function scriptFromText(text) {
+  try {
+    const v = JSON.parse(text);
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+function scriptToWrite(doc, hasLocal) {
+  const script = doc.source.script;
+  if (hasLocal || !script || typeof script !== "object") return null;
+  return `${JSON.stringify(script, null, 2)}
+`;
+}
+function embedScript(doc, dir) {
+  const path = join11(dir, "actions.json");
+  if (!existsSync10(path)) return;
+  const script = scriptFromText(readFileSync2(path, "utf8"));
+  if (script) doc.source.script = script;
+}
+async function writeScriptBeside(dir, doc) {
+  const path = join11(dir, "actions.json");
+  const text = scriptToWrite(doc, existsSync10(path));
+  if (text === null) return false;
+  await writeFile7(path, text, "utf8");
+  return true;
+}
+
+// src/plugin/folder.ts
+import { mkdir as mkdir5, writeFile as writeFile8 } from "fs/promises";
+import { join as join12 } from "path";
 import { recipeHints } from "@vosjs/shared/frontmatter";
 import { migrateHostedDoc } from "@vosjs/studio-core";
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["json", "help", "media"]);
@@ -5947,25 +6091,25 @@ 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 mkdir5(join11(out, "recipes"), { recursive: true });
+  await mkdir5(join12(out, "recipes"), { recursive: true });
   const lines = [];
   const recipes = [];
   for (const rec of payload.recipes) {
-    const path = join11(out, "recipes", safeName(rec.filename));
-    await writeFile7(path, rec.body ?? "");
+    const path = join12(out, "recipes", safeName(rec.filename));
+    await writeFile8(path, rec.body ?? "");
     recipes.push({ path, line: recipeLine(rec.filename, rec.body ?? "") });
   }
   for (const rec of payload.inheritedRecipes) {
     const from = safeName(rec.folderSlug ?? "inherited");
-    await mkdir5(join11(out, "recipes", "_inherited", from), { recursive: true });
-    const path = join11(
+    await mkdir5(join12(out, "recipes", "_inherited", from), { recursive: true });
+    const path = join12(
       out,
       "recipes",
       "_inherited",
       from,
       safeName(rec.filename)
     );
-    await writeFile7(path, rec.body ?? "");
+    await writeFile8(path, rec.body ?? "");
     recipes.push({
       path,
       line: `${recipeLine(rec.filename, rec.body ?? "")}  [inherited from ${rec.folderName ?? from}]`
@@ -5973,15 +6117,15 @@ async function cmdPull(argv) {
   }
   const members = [];
   for (const v of payload.voses) {
-    const dir = join11(out, "members", safeName(v.slug || v.title || v.id));
+    const dir = join12(out, "members", safeName(v.slug || v.title || v.id));
     await mkdir5(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)}`);
       continue;
     }
-    await writeFile7(
-      join11(dir, "config.json"),
+    await writeFile8(
+      join12(dir, "config.json"),
       JSON.stringify(cfg.body.config, null, 2)
     );
     let take = false;
@@ -5992,8 +6136,8 @@ async function cmdPull(argv) {
         { key }
       );
       if (doc.status === 200) {
-        await writeFile7(
-          join11(dir, "doc.json"),
+        await writeFile8(
+          join12(dir, "doc.json"),
           JSON.stringify(doc.body, null, 2)
         );
         take = true;
@@ -6119,8 +6263,8 @@ function storageStateInDir(dir) {
     if (!f.endsWith(".json") || f === "doc.json" || f === "meta.json" || f === "actions.json" || f === "cursor.json" || f === "vos.json" || f === "doc.prev.json")
       continue;
     try {
-      const v = JSON.parse(readFileSync2(join12(dir, f), "utf8"));
-      if (looksLikeStorageState(v)) return join12(dir, f);
+      const v = JSON.parse(readFileSync3(join13(dir, f), "utf8"));
+      if (looksLikeStorageState(v)) return join13(dir, f);
     } catch {
     }
   }
@@ -6141,7 +6285,7 @@ async function pushTake(dir, flags, r) {
     throw new Error(`doc.json fails lint:
   ${lint.problems.join("\n  ")}`);
   }
-  if (!existsSync10(take.paths.recording)) {
+  if (!existsSync11(take.paths.recording)) {
     throw new Error(
       "no recording in this take \u2014 record it, or `vos pull --media` to bring it home"
     );
@@ -6190,7 +6334,7 @@ async function pushTake(dir, flags, r) {
       throw new Error("push cancelled");
     }
   }
-  const bytes = await readFile9(take.paths.recording);
+  const bytes = await readFile10(take.paths.recording);
   const hash = createHash("sha256").update(bytes).digest("hex");
   const { type: contentType } = resolveMediaType({
     head: bytes.subarray(0, MEDIA_HEAD_BYTES),
@@ -6225,6 +6369,7 @@ async function pushTake(dir, flags, r) {
   if (upload.reused) r.log("  recording already hosted \u2014 reused");
   const docForPush = structuredClone(take.doc);
   docForPush.source.videoKey = assetUrl;
+  embedScript(docForPush, dir);
   await uploadDocRefs(sourceSidecarRefs(docForPush), dir, ctx, (l) => r.log(l));
   for (const field of ["micKey", "camKey"]) {
     const key = docForPush.source[field];
@@ -6362,9 +6507,9 @@ async function pullTake(dir, flags, r) {
       };
     }
     let media2;
-    if (flags.media && existsSync10(join12(dir, "doc.json"))) {
+    if (flags.media && existsSync11(join13(dir, "doc.json"))) {
       const local = JSON.parse(
-        await readFile9(join12(dir, "doc.json"), "utf8")
+        await readFile10(join13(dir, "doc.json"), "utf8")
       );
       media2 = await pullMedia(ctx, dir, local, r.log);
     }
@@ -6425,11 +6570,14 @@ async function pullTake(dir, flags, r) {
   const hostedDoc = migrateHostedDoc2(docRes.json);
   const doc = hostedDoc;
   const localRecording = takeMediaFile(dir, "recording", RECORDING_NAME);
-  if (existsSync10(localRecording)) {
+  if (existsSync11(localRecording)) {
     doc.source.videoKey = basename(localRecording);
   }
-  await writeJson(join12(dir, "doc.json"), doc, true);
+  await writeJson(join13(dir, "doc.json"), doc, true);
   const media = flags.media ? await pullMedia(ctx, dir, doc, r.log) : void 0;
+  if (flags.media && await writeScriptBeside(dir, doc)) {
+    r.log("  actions.json written from the document");
+  }
   const versions = await api(ctx, `/vos/${vosId}/versions`);
   const headRow = (versions.json.versions ?? []).find((v) => v.id === head);
   writeSyncState(dir, {
@@ -6463,6 +6611,7 @@ async function pushTakeClaimable(dir, flags, r) {
   const state = readSyncState(dir);
   const hosted = state?.hostedMedia ?? {};
   const docForPush = structuredClone(take.doc);
+  embedScript(docForPush, dir);
   const refs = [
     ...isTakeRelativeKey(docForPush.source.videoKey) ? [
       {
@@ -6484,8 +6633,8 @@ async function pushTakeClaimable(dir, flags, r) {
         `${ref.where} (${file}) is not a file this take fetched from vos.so, and a claimable push never uploads footage. Push the take with an account (vos login, then vos push ${dir}), or remix a public take fetched with \`vos fetch <url> --media\``
       );
     }
-    const path = join12(dir, file);
-    const now = existsSync10(path) ? await fileSha256(path) : null;
+    const path = join13(dir, file);
+    const now = existsSync11(path) ? await fileSha256(path) : null;
     if (now !== origin2.sha256) {
       throw new Error(
         `${ref.where} (${file}) changed since it was fetched, so it is no longer the hosted file. A claimable push names only the original; push with an account to upload the new one`
@@ -6519,10 +6668,10 @@ async function pushTakeClaimable(dir, flags, r) {
 }
 
 // src/plugin/program.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir6, readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync13 } from "fs";
+import { mkdir as mkdir6, readFile as readFile11, writeFile as writeFile9 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline/promises";
-import { basename as basename3, dirname as dirname2, join as join13 } from "path";
+import { basename as basename3, dirname as dirname2, join as join14 } from "path";
 import {
   CURRENT_CONFIG_VERSION,
   migrateConfig,
@@ -6656,12 +6805,12 @@ async function handoffLogin(url, r, opts = {}) {
 
 // src/plugin/programFiles.ts
 import { basename as basename2, extname as extname2, relative as relative2 } from "path";
-import { existsSync as existsSync11, realpathSync } from "fs";
+import { existsSync as existsSync12, realpathSync } from "fs";
 function isLocalName(value) {
   if (/^(https?:|data:|blob:|asset:|media:)/.test(value)) return false;
   if (value.startsWith("$")) return false;
   if (value.startsWith("<svg") || value.startsWith("<?xml")) return false;
-  if (value.startsWith("/")) return existsSync11(value);
+  if (value.startsWith("/")) return existsSync12(value);
   return true;
 }
 var FILE_EXT = /\.(png|jpe?g|webp|gif|avif|svg|mp4|webm|mov|mp3|m4a|ogg|wav|flac|aac|glb|gltf|woff2?|ttf|otf|hdr|exr)$/i;
@@ -6836,8 +6985,8 @@ function preflightConfig(parsed) {
 }
 function resolveConfigPath(target) {
   if (target.endsWith(".json")) return target;
-  const inDir = join13(target, "config.json");
-  if (existsSync12(inDir)) return inDir;
+  const inDir = join14(target, "config.json");
+  if (existsSync13(inDir)) return inDir;
   throw new UsageError(
     `${target} has no config.json (and is not a take \u2014 no doc.json)`
   );
@@ -6864,8 +7013,8 @@ async function cmdFetch(argv) {
   const slug = typeof vosMeta.slug === "string" && vosMeta.slug ? vosMeta.slug : vosId;
   const out = strFlag(flags, "out") ?? slug;
   await mkdir6(out, { recursive: true });
-  await writeFile8(
-    join13(out, "config.json"),
+  await writeFile9(
+    join14(out, "config.json"),
     JSON.stringify(cfg.body.config, null, 2)
   );
   const title = typeof vosMeta.title === "string" ? vosMeta.title : "";
@@ -6890,30 +7039,33 @@ async function cmdFetch(argv) {
       const hosted = migrateHostedDoc3(doc.body);
       const { config: own } = await writeProgramDoc(out, hosted);
       if (own) {
-        await writeFile8(join13(out, "config.json"), JSON.stringify(own, null, 2));
+        await writeFile9(join14(out, "config.json"), JSON.stringify(own, null, 2));
       }
     } else if (doc.status === 200) {
       take = true;
       const hosted = migrateHostedDoc3(doc.body);
-      await writeFile8(join13(out, "doc.json"), JSON.stringify(hosted, null, 2));
+      await writeFile9(join14(out, "doc.json"), JSON.stringify(hosted, null, 2));
       if (flags.media === true) {
         const media = await pullMedia({ origin, key }, out, hosted, r.log);
         await recordHostedMedia(out, vosId, media);
+        if (await writeScriptBeside(out, hosted)) {
+          r.log("  actions.json written from the document");
+        }
         mediaLine = media.downloaded.length ? ` + ${media.downloaded.map((m) => m.file).join(", ")}` : "";
       }
     }
   }
   let assetsLine = "";
   if (!take) {
-    const configPath = join13(out, "config.json");
-    const written = JSON.parse(await readFile10(configPath, "utf8"));
+    const configPath = join14(out, "config.json");
+    const written = JSON.parse(await readFile11(configPath, "utf8"));
     const hostedCount = manifestRefs(written).filter(
       ({ ref }) => hostedAssetId(ref, [origin, "https://vos.so", "https://www.vos.so"])
     ).length;
     if (hostedCount && flags.media === true) {
       const pulled = await pullManifest({ origin, key }, out, written, r.log);
       if (pulled) {
-        await writeFile8(
+        await writeFile9(
           configPath,
           JSON.stringify({ ...written, assets: pulled.assets }, null, 2)
         );
@@ -7033,7 +7185,7 @@ async function cmdPushProgram(argv) {
     api: strFlag(flags, "api")
   });
   const dir = dirname2(source);
-  const parsed = JSON.parse(await readFile10(source, "utf8"));
+  const parsed = JSON.parse(await readFile11(source, "utf8"));
   const pre = preflightConfig(parsed);
   if (!pre.ok || !pre.config) {
     for (const issue of pre.issues) r.log(`error ${issue}`);
@@ -7381,10 +7533,10 @@ async function cmdPullProgram(argv) {
   const cfg = await apiJson(origin, `/api/vos/${vosId}/config`, { key });
   if (cfg.status !== 200)
     throw new Error(apiError(`fetch head config for ${vosId}`, cfg));
-  const configPath = join13(dir, "config.json");
+  const configPath = join14(dir, "config.json");
   let backedUp = false;
-  if (existsSync12(configPath)) {
-    await writeFile8(join13(dir, "config.backup.json"), await readFile10(configPath));
+  if (existsSync13(configPath)) {
+    await writeFile9(join14(dir, "config.backup.json"), await readFile11(configPath));
     backedUp = true;
   }
   let headConfig = cfg.body.config;
@@ -7403,7 +7555,7 @@ async function cmdPullProgram(argv) {
       if (own) headConfig = own;
     }
   }
-  await writeFile8(configPath, JSON.stringify(headConfig, null, 2));
+  await writeFile9(configPath, JSON.stringify(headConfig, null, 2));
   writeSyncState(dir, {
     vosId,
     versionId: typeof head.id === "string" ? head.id : since
@@ -7417,7 +7569,7 @@ async function cmdPullProgram(argv) {
       protected: protectedIds,
       changes,
       out: configPath,
-      backup: backedUp ? join13(dir, "config.backup.json") : null
+      backup: backedUp ? join14(dir, "config.backup.json") : null
     },
     `Pulled ${changes.length} version${changes.length === 1 ? "" : "s"} \u2192 ${configPath}` + (backedUp ? ` (previous copy: config.backup.json)` : "") + `
 Re-apply your edit on the new head, then: vos push ${configPath} --vos ${vosId}`
@@ -7525,9 +7677,9 @@ function storedProgramConfig(config, programDoc) {
   return lowerProgramDoc(doc).config;
 }
 async function readProgramDoc(dir, config) {
-  const docPath = join13(dir, "doc.json");
-  if (!existsSync12(docPath)) return null;
-  const parsed = JSON.parse(await readFile10(docPath, "utf8"));
+  const docPath = join14(dir, "doc.json");
+  if (!existsSync13(docPath)) return null;
+  const parsed = JSON.parse(await readFile11(docPath, "utf8"));
   if (typeof parsed !== "object" || parsed === null || "source" in parsed)
     return null;
   const raw = parsed;
@@ -7535,23 +7687,23 @@ async function readProgramDoc(dir, config) {
   return { ...raw, program: { ...program, config } };
 }
 async function setProgramStill(dir, t) {
-  const docPath = join13(dir, "doc.json");
+  const docPath = join14(dir, "doc.json");
   let doc = { program: {}, audio: [] };
-  if (existsSync12(docPath)) {
-    const parsed = JSON.parse(await readFile10(docPath, "utf8"));
+  if (existsSync13(docPath)) {
+    const parsed = JSON.parse(await readFile11(docPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || "source" in parsed)
       throw new UsageError(
         `${docPath} is a take's document; a take's cover is its own "still" field`
       );
     doc = parsed;
   }
-  await writeFile8(docPath, JSON.stringify({ ...doc, still: t }, null, 2) + "\n");
+  await writeFile9(docPath, JSON.stringify({ ...doc, still: t }, null, 2) + "\n");
 }
 async function writeProgramDoc(dir, hosted) {
   const program = hosted.program && typeof hosted.program === "object" ? hosted.program : {};
   const { config, ...rest } = program;
   const onDisk = { ...hosted, program: rest };
-  await writeFile8(join13(dir, "doc.json"), JSON.stringify(onDisk, null, 2));
+  await writeFile9(join14(dir, "doc.json"), JSON.stringify(onDisk, null, 2));
   return {
     config: config && typeof config === "object" ? config : null
   };
@@ -7559,7 +7711,7 @@ async function writeProgramDoc(dir, hosted) {
 
 // src/plugin/asset.ts
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { basename as basename4 } from "path";
 
 // src/plugin/assetWords.ts
@@ -7702,7 +7854,7 @@ async function cmdPush(argv) {
   const uploaded = [];
   for (const file of positionals) {
     const name = basename4(file);
-    const body = readFileSync3(file);
+    const body = readFileSync4(file);
     const media = resolveMediaType({
       head: body.subarray(0, MEDIA_HEAD_BYTES),
       filename: name
@@ -7963,8 +8115,8 @@ async function cmdAsset(argv) {
 }
 
 // src/plugin/remove.ts
-import { existsSync as existsSync13, rmSync as rmSync2, statSync as statSync3 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync14, rmSync as rmSync2, statSync as statSync3 } from "fs";
+import { join as join15 } from "path";
 import { createInterface as createInterface3 } from "readline/promises";
 
 // src/plugin/trash.ts
@@ -8143,7 +8295,7 @@ async function cmdDelete(argv) {
     api: strFlag(flags, "api")
   }).replace(/\/+$/, "");
   const key = requireCredential(strFlag(flags, "key"));
-  const dir = existsSync13(target) && statSync3(target).isDirectory() ? target : null;
+  const dir = existsSync14(target) && statSync3(target).isDirectory() ? target : null;
   const vosId = dir ? readSyncState(dir)?.vosId : parseVosId(target);
   if (!vosId)
     throw new UsageError(
@@ -8186,7 +8338,7 @@ async function cmdDelete(argv) {
   const tracking = dir ?? trackingCwd(vosId);
   let unlinked = false;
   if (tracking) {
-    rmSync2(join14(tracking, SYNC_STATE_NAME), { force: true });
+    rmSync2(join15(tracking, SYNC_STATE_NAME), { force: true });
     unlinked = true;
   }
   const trashed = res.body.trashed === true;
@@ -8211,13 +8363,13 @@ async function cmdDelete(argv) {
 }
 function trackingCwd(vosId) {
   const cwd = process.cwd();
-  if (!existsSync13(join14(cwd, SYNC_STATE_NAME))) return null;
+  if (!existsSync14(join15(cwd, SYNC_STATE_NAME))) return null;
   return readSyncState(cwd)?.vosId === vosId ? cwd : null;
 }
 
 // src/plugin/buildProgram.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename5, dirname as dirname3, join as join15, resolve as resolve5 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename5, dirname as dirname3, join as join16, resolve as resolve5 } from "path";
 import { pathToFileURL } from "url";
 import { parse } from "acorn";
 import { fullAncestor } from "acorn-walk";
@@ -8418,7 +8570,7 @@ async function cmdBuild(argv) {
     throw new UsageError("vos build <program.mjs> [--out config.json] [--json]");
   const r = createReporter(flags.json === true);
   const file = resolve5(source);
-  const text = readFileSync4(file, "utf8");
+  const text = readFileSync5(file, "utf8");
   const mod = await import(`${pathToFileURL(file).href}?t=${Date.now()}`);
   const program = mod.default ?? mod.program;
   if (!program || typeof program !== "object")
@@ -8435,7 +8587,7 @@ async function cmdBuild(argv) {
     return EXIT_ERROR;
   }
   const out = resolve5(
-    strFlag(flags, "out") ?? join15(dirname3(file), "config.json")
+    strFlag(flags, "out") ?? join16(dirname3(file), "config.json")
   );
   writeFileSync2(out, JSON.stringify(built.config, null, 2) + "\n");
   const sidecar = out.replace(/\.json$/, "") + ".sources.json";
@@ -8452,8 +8604,8 @@ async function cmdBuild(argv) {
 
 // src/plugin/compare.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync14, mkdirSync as mkdirSync2, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, join as join16, resolve as resolve6 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync2, statSync as statSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join17, resolve as resolve6 } from "path";
 var BOOLEAN_FLAGS7 = /* @__PURE__ */ new Set(["json", "help"]);
 function sampleTimes(duration, every) {
   const step = every > 0 ? every : 1;
@@ -8520,7 +8672,7 @@ async function cmdCompare(argv) {
   const config = loaded.config;
   const duration = configDuration(config) ?? 5;
   const assets = await programAssets(config, {
-    baseDir: /^https?:\/\//.test(source) ? null : existsSync14(source) && statSync4(source).isDirectory() ? source : dirname4(source),
+    baseDir: /^https?:\/\//.test(source) ? null : existsSync15(source) && statSync4(source).isDirectory() ? source : dirname4(source),
     origin: platformOrigin({}),
     key: resolveCredential(),
     log: (line) => r.log(line)
@@ -8543,9 +8695,9 @@ async function cmdCompare(argv) {
   try {
     for (const t of times) {
       const tag = t.toFixed(2);
-      const refPng = join16(outDir, `src-${tag}.png`);
-      const vosPng = join16(outDir, `vos-${tag}.png`);
-      const sheet = join16(outDir, `sheet-${tag}.png`);
+      const refPng = join17(outDir, `src-${tag}.png`);
+      const vosPng = join17(outDir, `vos-${tag}.png`);
+      const sheet = join17(outDir, `sheet-${tag}.png`);
       const grab = ffmpeg([
         "-v",
         "error",
@@ -8602,7 +8754,7 @@ async function cmdCompare(argv) {
   } finally {
     await browser.close();
   }
-  const overview = join16(outDir, "overview.png");
+  const overview = join17(outDir, "overview.png");
   if (scores.length) {
     const inputs = scores.flatMap((s) => ["-i", s.sheet]);
     const scaled = scores.map((_, i) => `[${i}:v]scale=iw/3:-2[s${i}]`).join(";");
@@ -8628,7 +8780,7 @@ async function cmdCompare(argv) {
     overview
   };
   writeFileSync3(
-    join16(outDir, "report.json"),
+    join17(outDir, "report.json"),
     JSON.stringify(report, null, 2) + "\n"
   );
   r.done(
@@ -8639,28 +8791,28 @@ async function cmdCompare(argv) {
 }
 
 // src/plugin/port.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname7, join as join20, resolve as resolve9 } from "path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, join as join21, resolve as resolve9 } from "path";
 import { pathToFileURL as pathToFileURL3 } from "url";
 
 // src/plugin/portInventory.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import {
-  existsSync as existsSync16,
+  existsSync as existsSync17,
   mkdirSync as mkdirSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   readdirSync as readdirSync4,
   statSync as statSync6
 } from "fs";
-import { dirname as dirname5, join as join18, relative as relative3, resolve as resolve7 } from "path";
+import { dirname as dirname5, join as join19, relative as relative3, resolve as resolve7 } from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { findFontFamily as findFontFamily3 } from "@vosjs/shared";
 
 // src/plugin/portRemotion.ts
-import { existsSync as existsSync15, readFileSync as readFileSync5, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync5 } from "fs";
 import { createServer as createServer2 } from "http";
 import { createRequire } from "module";
-import { basename as basename6, extname as extname3, join as join17 } from "path";
+import { basename as basename6, extname as extname3, join as join18 } from "path";
 function themeColors(sources) {
   const out = {};
   const re = /\bconst\s+([A-Za-z_$][\w$]*)\s*(?::\s*string\s*)?=\s*['"](#[0-9a-fA-F]{3,8})['"]/g;
@@ -8726,14 +8878,14 @@ function sourceTexts(dir) {
     if (depth > 4 || out.length > 200) return;
     for (const name of readdirSync3(d)) {
       if (name === "node_modules" || name.startsWith(".")) continue;
-      const p = join17(d, name);
+      const p = join18(d, name);
       if (statSync5(p).isDirectory()) walk(p, depth + 1);
       else if (/\.(tsx?|jsx?|mjs)$/.test(name))
-        out.push(readFileSync5(p, "utf8"));
+        out.push(readFileSync6(p, "utf8"));
     }
   };
-  const src = join17(dir, "src");
-  walk(existsSync15(src) ? src : dir, 0);
+  const src = join18(dir, "src");
+  walk(existsSync16(src) ? src : dir, 0);
   return out;
 }
 function entryPoint(dir) {
@@ -8745,7 +8897,7 @@ function entryPoint(dir) {
     "remotion/index.ts",
     "remotion/index.tsx"
   ])
-    if (existsSync15(join17(dir, p))) return join17(dir, p);
+    if (existsSync16(join18(dir, p))) return join18(dir, p);
   return null;
 }
 var TYPES = {
@@ -8820,7 +8972,7 @@ async function readRemotion(dir, log) {
   const entry = entryPoint(dir);
   let bundler;
   try {
-    bundler = createRequire(join17(dir, "package.json"))("@remotion/bundler");
+    bundler = createRequire(join18(dir, "package.json"))("@remotion/bundler");
   } catch {
     log?.(
       "a Remotion project whose dependencies are not installed: run `npm install` in it so vos can read its compositions (words, scenes, faces); reading only the render"
@@ -8837,13 +8989,13 @@ async function readRemotion(dir, log) {
   } });
   const server = createServer2((rq, rs) => {
     const path = decodeURIComponent(new URL(rq.url ?? "/", "http://x").pathname);
-    let f = join17(out, path);
-    if (!f.startsWith(out) || !existsSync15(f) || statSync5(f).isDirectory())
-      f = join17(out, "index.html");
+    let f = join18(out, path);
+    if (!f.startsWith(out) || !existsSync16(f) || statSync5(f).isDirectory())
+      f = join18(out, "index.html");
     rs.writeHead(200, {
       "content-type": TYPES[extname3(f)] ?? "application/octet-stream"
     });
-    rs.end(readFileSync5(f));
+    rs.end(readFileSync6(f));
   }).listen(0, "127.0.0.1");
   await new Promise((r) => server.once("listening", r));
   const port = server.address().port;
@@ -8938,10 +9090,10 @@ async function readRemotion(dir, log) {
       perScene.push({ scene: s.name, texts: read.texts ?? [] });
     }
     const sources = sourceTexts(dir);
-    const publicDir = join17(dir, "public");
+    const publicDir = join18(dir, "public");
     const media = tree.audio.map((a) => {
       const name = basename6(a.src.split("?")[0]);
-      const local = existsSync15(join17(publicDir, name)) ? `public/${name}` : a.src;
+      const local = existsSync16(join18(publicDir, name)) ? `public/${name}` : a.src;
       return {
         kind: "audio",
         src: local,
@@ -8982,11 +9134,11 @@ async function readRemotion(dir, log) {
 
 // src/plugin/portInventory.ts
 function detectEngine(dir) {
-  if (existsSync16(join18(dir, "hyperframes.json"))) return "hyperframes";
-  const pkg = join18(dir, "package.json");
-  if (existsSync16(pkg)) {
+  if (existsSync17(join19(dir, "hyperframes.json"))) return "hyperframes";
+  const pkg = join19(dir, "package.json");
+  if (existsSync17(pkg)) {
     try {
-      const p = JSON.parse(readFileSync6(pkg, "utf8"));
+      const p = JSON.parse(readFileSync7(pkg, "utf8"));
       const deps = { ...p.dependencies ?? {}, ...p.devDependencies ?? {} };
       if ("remotion" in deps) return "remotion";
       if ("hyperframes" in deps) return "hyperframes";
@@ -8998,14 +9150,14 @@ function detectEngine(dir) {
   return "page";
 }
 function sourcePage(source) {
-  if (!existsSync16(source)) return null;
+  if (!existsSync17(source)) return null;
   if (statSync6(source).isFile()) return /\.html?$/i.test(source) ? source : null;
-  const index = join18(source, "index.html");
-  return existsSync16(index) ? index : null;
+  const index = join19(source, "index.html");
+  return existsSync17(index) ? index : null;
 }
 function findRender(dir) {
-  const videos = (d) => existsSync16(d) ? readdirSync4(d).filter((f) => /\.(mp4|webm|mov)$/i.test(f)).map((f) => join18(d, f)) : [];
-  for (const d of [join18(dir, "renders"), join18(dir, "out"), dir]) {
+  const videos = (d) => existsSync17(d) ? readdirSync4(d).filter((f) => /\.(mp4|webm|mov)$/i.test(f)).map((f) => join19(d, f)) : [];
+  for (const d of [join19(dir, "renders"), join19(dir, "out"), dir]) {
     const found = videos(d);
     if (found.length) return found[0];
   }
@@ -9276,7 +9428,7 @@ var SEEK_AND_READ = `((args) => {
 })`;
 async function readInventory(source, opts) {
   const abs = resolve7(source);
-  const dir = existsSync16(abs) && statSync6(abs).isDirectory() ? abs : dirname5(abs);
+  const dir = existsSync17(abs) && statSync6(abs).isDirectory() ? abs : dirname5(abs);
   const engine = detectEngine(dir);
   const page = sourcePage(abs);
   const render = opts.render === void 0 ? findRender(dir) : opts.render;
@@ -9379,7 +9531,7 @@ async function readInventory(source, opts) {
   if (render && duration) {
     const has = spawnSync2("ffmpeg", ["-version"]).status === 0;
     if (has) {
-      const refDir = join18(opts.outDir, "ref");
+      const refDir = join19(opts.outDir, "ref");
       mkdirSync3(refDir, { recursive: true });
       const times = read.scenes.length >= 3 ? read.scenes.map(
         (s) => s.start + (s.duration ?? 1) / 2
@@ -9388,7 +9540,7 @@ async function readInventory(source, opts) {
         (_, i) => i + 0.5
       );
       for (const t of times.filter((t2) => t2 < duration)) {
-        const file = join18(refDir, `src-${t.toFixed(2)}.png`);
+        const file = join19(refDir, `src-${t.toFixed(2)}.png`);
         const ok = spawnSync2("ffmpeg", [
           "-v",
           "error",
@@ -9442,8 +9594,8 @@ async function readInventory(source, opts) {
 
 // src/plugin/portScaffold.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { copyFileSync, existsSync as existsSync17, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { basename as basename7, dirname as dirname6, join as join19, resolve as resolve8 } from "path";
+import { copyFileSync, existsSync as existsSync18, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename7, dirname as dirname6, join as join20, resolve as resolve8 } from "path";
 import { findFontFamily as findFontFamily4, fontFaceUrl, nearestFontWeight } from "@vosjs/shared";
 
 // src/plugin/painterLib.ts
@@ -9854,7 +10006,7 @@ function planScaffold(inv, opts) {
   inv.media.filter((m) => m.kind === "audio" && m.src).forEach((m, i) => {
     const from = resolve8(opts.sourceDir, m.src);
     const name = basename7(from);
-    if (!existsSync17(from)) {
+    if (!existsSync18(from)) {
       report.push(
         `- the audio ${m.src} is not in the source folder; add it to doc.json by hand`
       );
@@ -10052,13 +10204,13 @@ function reportText(inv, r) {
 }
 function writeScaffold(plan, outDir) {
   mkdirSync4(outDir, { recursive: true });
-  writeFileSync4(join19(outDir, "program.mjs"), plan.program);
+  writeFileSync4(join20(outDir, "program.mjs"), plan.program);
   writeFileSync4(
-    join19(outDir, "doc.json"),
+    join20(outDir, "doc.json"),
     JSON.stringify(plan.doc, null, 2) + "\n"
   );
-  writeFileSync4(join19(dirname6(outDir), "REPORT.md"), plan.report);
-  for (const [from, name] of plan.copies) copyFileSync(from, join19(outDir, name));
+  writeFileSync4(join20(dirname6(outDir), "REPORT.md"), plan.report);
+  for (const [from, name] of plan.copies) copyFileSync(from, join20(outDir, name));
 }
 function probeAudioDuration(file) {
   const res = spawnSync3(
@@ -10092,7 +10244,7 @@ async function inventory(argv) {
     outDir,
     log: (l) => r.log(`note: ${l}`)
   });
-  const file = join20(outDir, "inventory.json");
+  const file = join21(outDir, "inventory.json");
   writeFileSync5(file, JSON.stringify(inv, null, 2) + "\n");
   const missing = inv.fonts.filter((f) => !f.catalog).map((f) => f.family);
   r.log(
@@ -10124,32 +10276,32 @@ function summary(inv) {
 async function scaffold(argv) {
   const { flags } = parseArgs(argv, BOOLEAN_FLAGS8);
   const r = createReporter(flags.json === true);
-  const from = resolve9(strFlag(flags, "from") ?? join20("port", "inventory.json"));
-  if (!existsSync18(from))
+  const from = resolve9(strFlag(flags, "from") ?? join21("port", "inventory.json"));
+  if (!existsSync19(from))
     throw new UsageError(
       `no inventory at ${from}: run npx vos port inventory <source> first`
     );
-  const inv = JSON.parse(readFileSync7(from, "utf8"));
+  const inv = JSON.parse(readFileSync8(from, "utf8"));
   const outDir = resolve9(
-    strFlag(flags, "out") ?? join20(dirname7(from), "program")
+    strFlag(flags, "out") ?? join21(dirname7(from), "program")
   );
   const plan = planScaffold(inv, {
     sourceDir: scaffoldSourceDir(inv),
     probeDuration: probeAudioDuration
   });
   writeScaffold(plan, outDir);
-  const programFile = join20(outDir, "program.mjs");
+  const programFile = join21(outDir, "program.mjs");
   const mod = await import(`${pathToFileURL3(programFile).href}?t=${Date.now()}`);
   const built = buildProgram(mod.default, "program.mjs", plan.program);
   for (const p of built.problems) r.log(`error ${p.fn}: ${p.message}`);
   if (built.problems.length) return EXIT_ERROR;
   writeFileSync5(
-    join20(outDir, "config.json"),
+    join21(outDir, "config.json"),
     JSON.stringify(built.config, null, 2) + "\n"
   );
   r.done(
-    { program: outDir, report: join20(dirname7(outDir), "REPORT.md") },
-    `Wrote ${outDir}/program.mjs, config.json and doc.json, and ${join20(dirname7(outDir), "REPORT.md")}. Translate the motion where it says TODO, then: npx vos build program.mjs && npx vos compare . --against <their render>`
+    { program: outDir, report: join21(dirname7(outDir), "REPORT.md") },
+    `Wrote ${outDir}/program.mjs, config.json and doc.json, and ${join21(dirname7(outDir), "REPORT.md")}. Translate the motion where it says TODO, then: npx vos build program.mjs && npx vos compare . --against <their render>`
   );
   return EXIT_OK;
 }
@@ -10160,7 +10312,7 @@ function scaffoldSourceDir(inv) {
 
 // src/plugin/recipe.ts
 import { createHash as createHash3 } from "crypto";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { basename as basename8 } from "path";
 var BOOLEAN_FLAGS9 = /* @__PURE__ */ new Set(["json", "help"]);
 var USAGE = "vos recipe push <file.md> (--folder <folderId|slug> | --asset <assetId>)";
@@ -10180,7 +10332,7 @@ async function cmdPush2(argv) {
     throw new UsageError(USAGE);
   }
   const filename = recipeFilename(file);
-  const body = readFileSync8(file);
+  const body = readFileSync9(file);
   const r = createReporter(flags.json === true);
   const origin = platformOrigin({
     origin: strFlag(flags, "origin"),
@@ -10246,7 +10398,7 @@ async function cmdRecipe(argv) {
 }
 
 // src/plugin/brand.ts
-import { writeFile as writeFile9 } from "fs/promises";
+import { writeFile as writeFile10 } from "fs/promises";
 import { resolve as resolve10 } from "path";
 import { parseFrontmatter as parseFrontmatter2 } from "@vosjs/shared/frontmatter";
 import { lookKindForGround } from "@vosjs/studio-core";
@@ -10600,7 +10752,7 @@ async function cmdBrand(argv) {
     composition,
     llms?.claim ?? design?.description ?? null
   );
-  await writeFile9(out, md);
+  await writeFile10(out, md);
   const k = composition.kit;
   r.done(
     {
@@ -10715,7 +10867,7 @@ async function recordHosted(input) {
 }
 
 // src/plugin/agentBrowser.ts
-import { writeFile as writeFile10 } from "fs/promises";
+import { writeFile as writeFile11 } from "fs/promises";
 import { resolve as resolve11 } from "path";
 function parseAgentBrowserLog(text) {
   const records = [];
@@ -11195,8 +11347,8 @@ async function cmdActions(argv) {
     if (!m) throw new UsageError("--viewport expects WxH, e.g. 1280x720");
     viewport = { width: Number(m[1]), height: Number(m[2]) };
   }
-  const { readFile: readFile13 } = await import("fs/promises");
-  const text = await readFile13(resolve11(input), "utf8");
+  const { readFile: readFile14 } = await import("fs/promises");
+  const text = await readFile14(resolve11(input), "utf8");
   const { records, problems } = parseAgentBrowserLog(text);
   for (const p of problems) r.log(`  ${p}`);
   const result = convertAgentBrowser(records, {
@@ -11213,7 +11365,7 @@ async function cmdActions(argv) {
     );
     return EXIT_ERROR;
   }
-  await writeFile10(out, `${JSON.stringify(result.actions, null, 2)}
+  await writeFile11(out, `${JSON.stringify(result.actions, null, 2)}
 `);
   r.done(
     { ok: true, out, url: result.actions.url ?? null, ...summary2(result) },
@@ -11233,9 +11385,9 @@ function summary2(result) {
 }
 async function cmdActionsScript(input, flags) {
   const r = createReporter(flags.json === true);
-  const { readFile: readFile13 } = await import("fs/promises");
+  const { readFile: readFile14 } = await import("fs/promises");
   const { shotList, formatShotList } = await import("./shotList-KH6FTX4L.js");
-  const raw = JSON.parse(await readFile13(resolve11(input), "utf8"));
+  const raw = JSON.parse(await readFile14(resolve11(input), "utf8"));
   const errors = validateActions(raw);
   if (errors.length) throw new UsageError(`${input}:
   ${errors.join("\n  ")}`);
@@ -11245,9 +11397,9 @@ async function cmdActionsScript(input, flags) {
 }
 
 // src/plugin/ingest.ts
-import { existsSync as existsSync19 } from "fs";
-import { copyFile, mkdir as mkdir7, readFile as readFile11, stat as stat2 } from "fs/promises";
-import { basename as basename9, join as join21, resolve as resolve12 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { copyFile, mkdir as mkdir7, readFile as readFile12, stat as stat2 } from "fs/promises";
+import { basename as basename9, join as join22, resolve as resolve12 } from "path";
 import { inflateRawSync } from "zlib";
 import {
   cursorFromPlaywrightTrace,
@@ -11335,7 +11487,7 @@ async function readTraceFile(path, offsetMs) {
     );
   }
   if (kind === "zip") {
-    const bytes = new Uint8Array(await readFile11(path));
+    const bytes = new Uint8Array(await readFile12(path));
     const entry = playwrightTraceEntry(zipEntries(bytes));
     if (!entry) {
       throw new UsageError(
@@ -11348,7 +11500,7 @@ async function readTraceFile(path, offsetMs) {
     );
     return cursorFromPlaywrightTrace(text2, { offsetMs });
   }
-  const text = await readFile11(path, "utf8");
+  const text = await readFile12(path, "utf8");
   return cursorFromTrace(basename9(path), text, { offsetMs });
 }
 function parseViewport(v) {
@@ -11365,7 +11517,7 @@ async function cmdIngest(argv) {
       "vos ingest <video.webm|mp4> [--cursor <trace.zip|steps.jsonl|cursor.csv>] [--as footage|take] [--out take] [--offset <ms>] [--viewport WxH] [--background <slug|url|none>] [--json]"
     );
   const videoPath = resolve12(source);
-  if (!existsSync19(videoPath)) throw new UsageError(`${source}: no such file`);
+  if (!existsSync20(videoPath)) throw new UsageError(`${source}: no such file`);
   const r = createReporter(flags.json === true);
   const outDir = resolve12(strFlag(flags, "out") ?? "take");
   const offsetMs = numFlag(flags, "offset", 0);
@@ -11392,7 +11544,7 @@ async function cmdIngest(argv) {
     trace = await readTraceFile(resolve12(cursorPath), offsetMs);
     for (const n of trace.notes) r.log(`note: ${n}`);
   }
-  if (existsSync19(join21(outDir, "meta.json"))) {
+  if (existsSync20(join22(outDir, "meta.json"))) {
     const { prevDoc, kept } = await prepareReRecord(outDir);
     r.log(
       `note: re-ingesting into ${outDir}; kept ${kept.length ? kept.join(", ") : "nothing"}` + (prevDoc ? `; apply the previous cut with: vos plan ${outDir} --reuse` : "")
@@ -11400,7 +11552,7 @@ async function cmdIngest(argv) {
   }
   await mkdir7(outDir, { recursive: true });
   const paths = await ensureTakeDir(outDir);
-  const recording = join21(outDir, `recording.${probed.ext}`);
+  const recording = join22(outDir, `recording.${probed.ext}`);
   r.log("copying the recording\u2026");
   const remuxed = await copyRecording(videoPath, recording, probed.ext);
   const viewport = viewportFlag ?? trace?.viewport ?? {
@@ -11468,19 +11620,19 @@ async function cmdIngest(argv) {
 import { spawnSync as spawnSync4 } from "child_process";
 import {
   cpSync,
-  existsSync as existsSync21,
+  existsSync as existsSync22,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   rmSync as rmSync3,
   writeFileSync as writeFileSync6
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 import { chromium as chromium2 } from "playwright";
 
 // src/plugin/machine.ts
-import { existsSync as existsSync20, readFileSync as readFileSync9, readdirSync as readdirSync5, statSync as statSync7 } from "fs";
-import { dirname as dirname8, join as join22 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync10, readdirSync as readdirSync5, statSync as statSync7 } from "fs";
+import { dirname as dirname8, join as join23 } from "path";
 var AGENT_NAMES = [
   "claude",
   "cursor",
@@ -11500,17 +11652,17 @@ var HOME_DIRS = {
   copilot: [".copilot"]
 };
 function detectAgents(root, opts = {}) {
-  const exists = opts.exists ?? existsSync20;
+  const exists = opts.exists ?? existsSync21;
   const out = [];
   for (const agent of AGENT_NAMES) {
     for (const rel of PROJECT_DIRS[agent]) {
-      const dir = join22(root, rel);
+      const dir = join23(root, rel);
       if (exists(dir)) out.push({ agent, dir, scope: "project" });
     }
-    if (agent === "copilot" && !out.some((h) => h.agent === "copilot") && exists(join22(root, ".github", "copilot-instructions.md"))) {
+    if (agent === "copilot" && !out.some((h) => h.agent === "copilot") && exists(join23(root, ".github", "copilot-instructions.md"))) {
       out.push({
         agent,
-        dir: join22(root, ".github", "copilot"),
+        dir: join23(root, ".github", "copilot"),
         scope: "project"
       });
     }
@@ -11518,7 +11670,7 @@ function detectAgents(root, opts = {}) {
   if (opts.global && opts.home) {
     for (const agent of AGENT_NAMES) {
       for (const rel of HOME_DIRS[agent]) {
-        const dir = join22(opts.home, rel);
+        const dir = join23(opts.home, rel);
         if (exists(dir)) out.push({ agent, dir, scope: "global" });
       }
     }
@@ -11536,18 +11688,18 @@ function agentsFromFlag(value, root) {
   return {
     homes: wanted.map((agent) => ({
       agent,
-      dir: join22(root, PROJECT_DIRS[agent][0]),
+      dir: join23(root, PROJECT_DIRS[agent][0]),
       scope: "project"
     }))
   };
 }
 function skillsDirFor(home) {
-  return join22(home.dir, "skills");
+  return join23(home.dir, "skills");
 }
 function fallbackSkillsHome(root) {
-  return { agent: "codex", dir: join22(root, ".agents"), scope: "project" };
+  return { agent: "codex", dir: join23(root, ".agents"), scope: "project" };
 }
-function installedSkills(dir, exists = existsSync20, list = (p) => {
+function installedSkills(dir, exists = existsSync21, list = (p) => {
   try {
     return readdirSync5(p);
   } catch {
@@ -11555,7 +11707,7 @@ function installedSkills(dir, exists = existsSync20, list = (p) => {
   }
 }) {
   if (!exists(dir)) return [];
-  return list(dir).filter((name) => exists(join22(dir, name, "SKILL.md"))).sort();
+  return list(dir).filter((name) => exists(join23(dir, name, "SKILL.md"))).sort();
 }
 var RULES_BEGIN = "<!-- vos:begin (written by vos setup; the block is replaced on the next run) -->";
 var RULES_END = "<!-- vos:end -->";
@@ -11588,10 +11740,10 @@ ${RULES_BLOCK}
   }
   return { text, changed: text !== current };
 }
-function rulesFileFor(root, exists = existsSync20) {
-  const agents = join22(root, "AGENTS.md");
+function rulesFileFor(root, exists = existsSync21) {
+  const agents = join23(root, "AGENTS.md");
   if (exists(agents)) return agents;
-  const claude = join22(root, "CLAUDE.md");
+  const claude = join23(root, "CLAUDE.md");
   if (exists(claude)) return claude;
   return agents;
 }
@@ -11600,14 +11752,14 @@ function chromeCandidates(platform, env) {
     return ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"];
   if (platform === "win32")
     return [
-      join22(
+      join23(
         env["PROGRAMFILES"] ?? "C:\\Program Files",
         "Google",
         "Chrome",
         "Application",
         "chrome.exe"
       ),
-      join22(
+      join23(
         env["LOCALAPPDATA"] ?? "",
         "Google",
         "Chrome",
@@ -11694,13 +11846,13 @@ function doctorReport(facts) {
 function bundledSkillsDir(from) {
   let dir = dirname8(from);
   for (let i = 0; i < 6; i++) {
-    const pkg = join22(dir, "package.json");
-    if (existsSync20(pkg)) {
+    const pkg = join23(dir, "package.json");
+    if (existsSync21(pkg)) {
       try {
-        const name = JSON.parse(readFileSync9(pkg, "utf8")).name;
+        const name = JSON.parse(readFileSync10(pkg, "utf8")).name;
         if (name === "@vosjs/cli") {
-          const skills = join22(dir, "skills");
-          return existsSync20(skills) && statSync7(skills).isDirectory() ? skills : null;
+          const skills = join23(dir, "skills");
+          return existsSync21(skills) && statSync7(skills).isDirectory() ? skills : null;
         }
       } catch {
       }
@@ -11731,7 +11883,7 @@ function npx() {
 function bundledChromium() {
   try {
     const p = chromium2.executablePath();
-    return p && existsSync21(p) ? p : null;
+    return p && existsSync22(p) ? p : null;
   } catch {
     return null;
   }
@@ -11740,7 +11892,7 @@ function probe2() {
   return probeBrowser({
     platform: process.platform,
     env: process.env,
-    exists: existsSync21,
+    exists: existsSync22,
     bundled: bundledChromium
   });
 }
@@ -11844,7 +11996,7 @@ async function cmdSetup(argv) {
         const dest = skillsDirFor(home);
         mkdirSync6(dest, { recursive: true });
         for (const name of installedSkills(bundled)) {
-          cpSync(join23(bundled, name), join23(dest, name), { recursive: true });
+          cpSync(join24(bundled, name), join24(dest, name), { recursive: true });
         }
       }
       skillsVia = "bundled";
@@ -11879,7 +12031,7 @@ async function cmdSetup(argv) {
   let rules = null;
   if (!noRules) {
     const file = rulesFileFor(root);
-    const existing = existsSync21(file) ? readFileSync10(file, "utf8") : null;
+    const existing = existsSync22(file) ? readFileSync11(file, "utf8") : null;
     const { text, changed } = applyRulesBlock(existing);
     if (changed) writeFileSync6(file, text);
     rules = { file, changed };
@@ -11993,7 +12145,7 @@ async function cmdWhoami(argv) {
 function cmdLogout(argv) {
   const { flags } = parseArgs(argv, BOOLEAN_FLAGS11);
   const r = reporterFor(flags);
-  const had = existsSync21(CREDENTIALS_PATH);
+  const had = existsSync22(CREDENTIALS_PATH);
   rmSync3(CREDENTIALS_PATH, { force: true });
   const envKey = Boolean(process.env.VOS_API_KEY?.trim());
   r.done(
@@ -12199,12 +12351,16 @@ The re-render loop (re-recording the same script after the product
 changed): record into the SAME take dir \u2014 footage/cursor/meta are
 replaced, the cut survives as doc.prev.json \u2014 then plan --reuse re-times
 it onto the new recording. meta.json carries steps (when each actions
-step ran); a span may carry anchor {step, at, offset} tying it to a step
-id/index for exact re-timing; unanchored human spans map piecewise
-through matched step edges; autos re-plan; overlays/audio keep OUTPUT
-times. The done event's reuse block NAMES whatever could not follow \u2014
-fix by exception, never re-cut from scratch. Give steps ids in
-actions.json so anchors survive script edits.
+step ran); a human span follows the step it was made on (its window, or
+the gesture just before it), keeping its offset exactly, or an explicit
+anchor {step, at, offset}; a span between steps maps piecewise through
+matched step edges; a span whose step vanished is dropped and named with
+what it framed; autos re-plan; a layer pinned to a step follows its new
+output time, every other layer and audio keep OUTPUT times, and a layer
+over a step that moved is named with the pin to write. The done event's
+reuse block NAMES whatever could not follow \u2014 fix by exception, never
+re-cut from scratch. Give steps ids in actions.json so re-timing survives
+script edits.
 
 record --strict exits 2 when any selector was skipped, the page never
 reached networkidle, or the take hit --max-duration (the done event lists
@@ -12328,7 +12484,7 @@ lint-gated, so a bad override fails like a bad doc.json):
                        first ready loop (the house backdrop the studio opens on), or a flat ground offline
 `;
 async function loadActions(file) {
-  const raw = JSON.parse(await readFile12(file, "utf8"));
+  const raw = JSON.parse(await readFile13(file, "utf8"));
   const errors = validateActions(raw);
   if (errors.length)
     throw new UsageError(`invalid actions file:
@@ -12391,7 +12547,7 @@ function takeStorageState(flags) {
   const raw = strFlag(flags, "storage-state");
   if (!raw) return void 0;
   const path = resolve13(raw);
-  if (!existsSync22(path))
+  if (!existsSync23(path))
     throw new UsageError(`--storage-state: no such file: ${path}`);
   return path;
 }
@@ -12404,7 +12560,7 @@ function takeSessionName(flags, storageState) {
     throw new UsageError(
       "--session and --storage-state are two doors to one take: a persistent profile cannot take a storage state. Pass one"
     );
-  if (!existsSync22(sessionDir(name)))
+  if (!existsSync23(sessionDir(name)))
     throw new UsageError(
       `no session "${name}". Make one: vos session open <url> --name ${name} (a Chrome window opens; sign in and close it)`
     );
@@ -12627,7 +12783,7 @@ ${lines.join("\n")}
   }
   const paths = takePaths(outDir);
   const prepare = async () => {
-    if (existsSync22(join24(outDir, "meta.json"))) {
+    if (existsSync23(join25(outDir, "meta.json"))) {
       const { prevDoc, kept } = await prepareReRecord(outDir);
       r.log(
         `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" : "")
@@ -12692,7 +12848,7 @@ ${lines.join("\n")}
       },
       strictFail ? `STRICT: take recorded but incomplete \u2014 ${strictReason(rec)}; fix the flow and re-record.${skippedNote}${exposureNote(rec)}` : `Take ready: ${outDir}
   ${(rec.meta.durationMs / 1e3).toFixed(1)}s \xB7 ${rec.frames.length} frames \xB7 ${rec.events.length} cursor events \xB7 ${clicks} clicks \xB7 ${plan.doc.zoom.length} zoom spans planned \xB7 ${rec.freezePct}% frozen \xB7 ${rec.dead.pct}% dead${deadWarns(rec.dead) ? " \u26A0 " + deadLine(rec.dead) : ""}${skippedNote}
-  Next: edit ${join24(outDir, "doc.json")} (optional), then: vos render ${outDir}${exposureNote(rec)}`
+  Next: edit ${join25(outDir, "doc.json")} (optional), then: vos render ${outDir}${exposureNote(rec)}`
     );
     return strictFail ? EXIT_USAGE : EXIT_OK;
   } finally {
@@ -12718,7 +12874,7 @@ async function cmdCreate2(argv) {
     throw new UsageError('no URL \u2014 set "url" in the actions file or pass --url');
   const outDir = resolve13(strFlag(flags, "out") ?? "take");
   const format = videoFormat(strFlag(flags, "format"), positionals[0]);
-  const out = positionals[0] ?? join24(outDir, `out.${format}`);
+  const out = positionals[0] ?? join25(outDir, `out.${format}`);
   const parallel = numFlag(flags, "parallel", 1);
   if (!Number.isInteger(parallel) || parallel < 1 || parallel > 16) {
     throw new UsageError("--parallel expects an integer between 1 and 16");
@@ -12731,7 +12887,7 @@ async function cmdCreate2(argv) {
   const headers = takeHeaders(multi);
   const paths = takePaths(outDir);
   const prepare = async () => {
-    if (existsSync22(join24(outDir, "meta.json"))) {
+    if (existsSync23(join25(outDir, "meta.json"))) {
       const { prevDoc, kept } = await prepareReRecord(outDir);
       r.log(
         `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" : "")
@@ -12838,24 +12994,24 @@ async function cmdPlan(argv) {
     );
   const r = createReporter(flags.json === true);
   if (flags.fresh === true) {
-    await rm2(join24(dir, "doc.json"), { force: true });
+    await rm2(join25(dir, "doc.json"), { force: true });
     r.log("note: --fresh discarded the existing doc.json");
   }
   let reuse;
   if (flags.reuse === true) {
-    const from = resolve13(strFlag(flags, "from") ?? join24(dir, PREV_DOC_NAME));
-    if (!existsSync22(from)) {
+    const from = resolve13(strFlag(flags, "from") ?? join25(dir, PREV_DOC_NAME));
+    if (!existsSync23(from)) {
       throw new UsageError(
         `--reuse: ${from} does not exist \u2014 a re-record into this take writes doc.prev.json, or pass --from <doc.json>`
       );
     }
     reuse = {
       from,
-      doc: JSON.parse(await readFile12(from, "utf8"))
+      doc: JSON.parse(await readFile13(from, "utf8"))
     };
   }
   const style = await resolveStyleRef(flags);
-  const hasDoc = existsSync22(join24(dir, "doc.json"));
+  const hasDoc = existsSync23(join25(dir, "doc.json"));
   const backdrop = hasDoc ? null : await takeBackdrop(flags, r);
   const release = await releaseInputs(dir, flags, r, multi.with ?? []);
   const motionWanted = !hasDoc || flags.motion === true || flags.fresh === true;
@@ -12913,7 +13069,7 @@ async function cmdPlan(argv) {
       ...s.motion ? { motion: s.motion } : {},
       ...s.reuse ? { reuse: s.reuse } : {}
     },
-    `${s.reuse ? "Reused" : s.fresh ? "Planned" : "Refreshed"} ${join24(dir, "doc.json")}: ${s.zoomAuto} auto + ${s.zoomManual} manual zoom spans${s.cursorKept ? "" : " (cursor track dropped)"}${layoutLines}${motionLines}${reuseLines}`
+    `${s.reuse ? "Reused" : s.fresh ? "Planned" : "Refreshed"} ${join25(dir, "doc.json")}: ${s.zoomAuto} auto + ${s.zoomManual} manual zoom spans${s.cursorKept ? "" : " (cursor track dropped)"}${layoutLines}${motionLines}${reuseLines}`
   );
   return EXIT_OK;
 }
@@ -13036,7 +13192,7 @@ async function cmdRender(argv) {
     );
   const r = createReporter(flags.json === true);
   const format = videoFormat(strFlag(flags, "format"), positionals[1]);
-  const out = positionals[1] ?? join24(dir, `out.${format}`);
+  const out = positionals[1] ?? join25(dir, `out.${format}`);
   const parallel = numFlag(flags, "parallel", 1);
   if (!Number.isInteger(parallel) || parallel < 1 || parallel > 16) {
     throw new UsageError("--parallel expects an integer between 1 and 16");
@@ -13267,15 +13423,15 @@ async function resolveStyleRef(flags) {
 }
 async function resolveDocRef(ref, flags, what) {
   const styleRef = ref;
-  const file = existsSync22(styleRef) ? resolve13(
+  const file = existsSync23(styleRef) ? resolve13(
     styleRef,
-    existsSync22(join24(styleRef, "doc.json")) ? "doc.json" : ""
+    existsSync23(join25(styleRef, "doc.json")) ? "doc.json" : ""
   ) : null;
-  if (file && existsSync22(file)) {
+  if (file && existsSync23(file)) {
     return {
       from: file,
       doc: migrateHostedDoc4(
-        JSON.parse(await readFile12(file, "utf8"))
+        JSON.parse(await readFile13(file, "utf8"))
       )
     };
   }
@@ -13327,7 +13483,7 @@ async function cmdDigest(argv) {
   const take = await loadTake(dir);
   if (!take.doc) throw new UsageError(`${dir} has no doc.json \u2014 run plan first`);
   const transcriptPath = strFlag(flags, "transcript");
-  const transcript = transcriptPath ? parseTranscript(JSON.parse(await readFile12(transcriptPath, "utf8"))) : null;
+  const transcript = transcriptPath ? parseTranscript(JSON.parse(await readFile13(transcriptPath, "utf8"))) : null;
   const style = await resolveStyleRef(flags);
   const noFrames = flags["no-frames"] === true;
   let browser = null;
@@ -13358,7 +13514,7 @@ async function cmdDigest(argv) {
         kinds,
         frames: d.images.full,
         crops: d.images.crop,
-        sheet: d.images.sheet ? join24(result.outDir, d.images.sheet) : null,
+        sheet: d.images.sheet ? join25(result.outDir, d.images.sheet) : null,
         scenes: kinds.scene ?? 0,
         sourceDuration: d.take.sourceDuration,
         outputDuration: d.take.outputDuration,
@@ -13386,7 +13542,7 @@ async function cmdOpen(argv) {
   if (!dir) throw new UsageError("vos open <take> [--studio <url>]");
   const r = createReporter(flags.json === true);
   const take = await loadTake(dir);
-  if (!existsSync22(take.paths.recording)) {
+  if (!existsSync23(take.paths.recording)) {
     throw new UsageError(`${dir} has no recording \u2014 re-run record`);
   }
   const studio = (strFlag(flags, "studio") ?? platformOrigin()).replace(
@@ -13443,7 +13599,7 @@ async function cmdCallout(argv) {
       `no register: put a BRAND.md beside the take (vos brand <url> --out BRAND.md; its bgA and accent are the ground and the accent), or pass --ground #hex --accent #hex`
     );
   const codeFile = strFlag(flags, "code-file");
-  const code = codeFile ? await readFile12(codeFile, "utf8") : strFlag(flags, "code");
+  const code = codeFile ? await readFile13(codeFile, "utf8") : strFlag(flags, "code");
   const words2 = {
     kicker: strFlag(flags, "kicker"),
     title: strFlag(flags, "title"),
@@ -13522,7 +13678,7 @@ async function cmdValidate(argv) {
   const target = positionals[0];
   if (!target) throw new UsageError("vos validate <actions.json|take>");
   const r = createReporter(flags.json === true);
-  const kitTarget = target.endsWith("kit.json") ? target : existsSync22(join24(target, "kit.json")) && !isTakeDir(target) ? join24(target, "kit.json") : null;
+  const kitTarget = target.endsWith("kit.json") ? target : existsSync23(join25(target, "kit.json")) && !isTakeDir(target) ? join25(target, "kit.json") : null;
   if (kitTarget) {
     const picture = flags.picture === true;
     const verdict = await validateKit(kitTarget, { picture });
@@ -13554,9 +13710,9 @@ async function cmdValidate(argv) {
     r.done({ valid: true, target }, `${target}: valid actions file`);
     return EXIT_OK;
   }
-  if (!isTakeDir(target) && existsSync22(join24(target, "config.json"))) {
+  if (!isTakeDir(target) && existsSync23(join25(target, "config.json"))) {
     const parsed = JSON.parse(
-      await readFile12(join24(target, "config.json"), "utf8")
+      await readFile13(join25(target, "config.json"), "utf8")
     );
     const pre = preflightConfig(parsed);
     const problems2 = pre.ok ? [] : pre.issues.map((i) => `config.json: ${i}`);
@@ -13597,7 +13753,7 @@ async function cmdValidate(argv) {
   const take = await loadTake(target);
   const problems = [];
   const warnings = [];
-  if (!existsSync22(take.paths.recording)) {
+  if (!existsSync23(take.paths.recording)) {
     problems.push("missing recording (re-run record)");
   } else {
     const mismatch = containerMismatch(
@@ -13982,7 +14138,7 @@ async function cmdSession(argv) {
       if (!arg) throw new UsageError(usage);
       const bad = sessionNameVerdict(arg);
       if (bad) throw new UsageError(bad);
-      if (!existsSync22(sessionDir(arg)))
+      if (!existsSync23(sessionDir(arg)))
         throw new UsageError(`no session "${arg}" (vos session list)`);
       const summary3 = await summarizeSession(arg);
       const url = strFlag(flags, "url");
@@ -14082,4 +14238,4 @@ export {
   verbHelp,
   run
 };
-//# sourceMappingURL=chunk-NHJRD2XC.js.map
+//# sourceMappingURL=chunk-KIFXVPBR.js.map