@vosjs/cli 0.53.6 → 0.54.0

package/dist/{chunk-MJYXP4AA.js → chunk-M22MAUMZ.js}

@@ -9,6 +9,7 @@ import {
   apiError,
   apiJson,
   clientId,
+  configDuration,
   containerMismatch,
   deriveSlug,
   directoryKind,
@@ -16,12 +17,16 @@ import {
   formatChanges,
   hasFlag,
   launchBrowser,
+  loadVosConfig,
   nameForType,
   numFlag2 as numFlag,
   parseArgs2 as parseArgs,
+  parseTimes,
   parseVosId,
   platformOrigin,
   readSyncState,
+  reencodeStill,
+  renderStill,
   requireCredential,
   resolveCredential,
   resolveMediaType,
@@ -31,7 +36,7 @@ import {
   videoFormat,
   writeCredential,
   writeSyncState
-} from "./chunk-WLUWDQQO.js";
+} from "./chunk-SAWRKTRX.js";
 import {
   deadLine,
   deadWarns
@@ -94,8 +99,8 @@ function landedLines(l) {
 
 // src/plugin/run.ts
 import { mkdir as mkdir11, readFile as readFile17, rm as rm5 } from "fs/promises";
-import { existsSync as existsSync20 } from "fs";
-import { join as join22, resolve as resolve10 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { join as join27, resolve as resolve15 } from "path";
 import {
   END_CARD_FROM as END_CARD_FROM2,
   docOutputDuration as docOutputDuration3,
@@ -2334,10 +2339,10 @@ function startTakeServer(rootDir, pages) {
     res.writeHead(404).end();
   });
   return new Promise(
-    (resolve11) => server.listen(0, () => {
+    (resolve16) => server.listen(0, () => {
       const addr = server.address();
       const port = typeof addr === "object" && addr ? addr.port : 0;
-      resolve11({ base: `http://localhost:${port}`, close: () => server.close() });
+      resolve16({ base: `http://localhost:${port}`, close: () => server.close() });
     })
   );
 }
@@ -3584,7 +3589,7 @@ async function momentsFor(dir, doc) {
   }
   return momentsFromDoc2(doc, planForDigest2(doc));
 }
-function parseTimes(spec, duration) {
+function parseTimes2(spec, duration) {
   return spec.split(",").map((s) => s.trim()).filter(Boolean).map((s) => {
     if (s.endsWith("%")) {
       const p = Number(s.slice(0, -1));
@@ -4211,11 +4216,11 @@ var DUPLICATE_BITS = 6;
 var POPULATED_INK = 0.12;
 function pickMoments(measured, opts = {}) {
   const minInk = opts.minInk ?? 0.06;
-  const relative2 = opts.relativeInk ?? 0.4;
+  const relative3 = opts.relativeInk ?? 0.4;
   const bits = opts.duplicateBits ?? DUPLICATE_BITS;
   const inks = measured.map((m) => m.ink).sort((a, b) => a - b);
   const median2 = inks[inks.length >> 1] ?? 0;
-  const floor = Math.max(minInk, Math.min(POPULATED_INK, median2 * relative2));
+  const floor = Math.max(minInk, Math.min(POPULATED_INK, median2 * relative3));
   const kept = [];
   const dropped = [];
   for (const m of measured) {
@@ -4846,7 +4851,7 @@ async function pickStillTimes(browser, dir, doc, duration, opts) {
   const vh = meta.captureHeight ?? meta.height;
   const probeDir = await mkdtemp(join7(tmpdir(), "vos-moments-"));
   try {
-    const probe2 = await framesTake(browser, dir, {
+    const probe3 = await framesTake(browser, dir, {
       times: candidates.map((c) => c.time),
       width: PROBE_WIDTH,
       height: Math.max(2, Math.round(PROBE_WIDTH * vh / vw / 2) * 2),
@@ -4857,7 +4862,7 @@ async function pickStillTimes(browser, dir, doc, duration, opts) {
       }
     });
     const byTime = /* @__PURE__ */ new Map();
-    for (const frame of probe2.frames) {
+    for (const frame of probe3.frames) {
       const img = decodePng(new Uint8Array(await readFile7(frame.file)));
       if (!img) continue;
       const whole = { x: 0, y: 0, w: img.w, h: img.h };
@@ -6059,10 +6064,10 @@ function duplicateFindings(stills) {
     };
   });
 }
-async function videoFrame(file, at2, ffmpeg) {
+async function videoFrame(file, at2, ffmpeg2) {
   try {
     const { stdout } = await execFileP(
-      ffmpeg,
+      ffmpeg2,
       [
         "-v",
         "error",
@@ -6097,7 +6102,7 @@ async function pictureChecks(assets) {
   const findings = [];
   const measured = [];
   const stills = [];
-  let ffmpeg = null;
+  let ffmpeg2 = null;
   for (const a of assets) {
     if (/\.png$/i.test(a.file)) {
       const img = decodePng(new Uint8Array(await readFile11(a.file)));
@@ -6126,8 +6131,8 @@ async function pictureChecks(assets) {
       continue;
     }
     if (/\.(mp4|webm|mov)$/i.test(a.file)) {
-      if (ffmpeg === null) ffmpeg = await onPath("ffmpeg");
-      if (!ffmpeg) {
+      if (ffmpeg2 === null) ffmpeg2 = await onPath("ffmpeg");
+      if (!ffmpeg2) {
         findings.push({
           code: "firstlast",
           severity: "info",
@@ -6514,10 +6519,10 @@ async function openSession(name, url, opts = { log: () => {
   opts.log(
     `a Chrome window opened on session "${name}": sign in to ${new URL(url).host}, ${leave}`
   );
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve16, reject) => {
     const child = spawn(exe, args, { stdio: "ignore" });
     child.on("error", reject);
-    child.on("exit", (code) => resolve11({ code }));
+    child.on("exit", (code) => resolve16({ code }));
   });
 }
 async function withSession(name, fn, opts = {}) {
@@ -7339,7 +7344,7 @@ async function cmdPull(argv) {
     members.push({ dir, id: v.id, title: v.title, take });
   }
   const assets = payload.assets.filter((a) => a.category !== "recipe");
-  const summary2 = [
+  const summary3 = [
     `Pulled ${folder.name} (${folder.slug}) \u2192 ${out}/`,
     ...folder.id && payload.folder.description ? [`  ${payload.folder.description}`] : [],
     `  recipes (${recipes.length}) \u2014 read EVERY one:`,
@@ -7366,7 +7371,7 @@ async function cmdPull(argv) {
       assets,
       subfolders: payload.subfolders
     },
-    summary2
+    summary3
   );
   return EXIT_OK;
 }
@@ -8561,9 +8566,9 @@ async function cmdLogin(argv) {
   return storeKey(key, origin, r);
 }
 async function storeKey(key, origin, r) {
-  const probe2 = await apiJson(origin, "/api/folders", { key });
-  if (probe2.status === 401 || probe2.status === 403) {
-    throw new Error(apiError("validate key", probe2));
+  const probe3 = await apiJson(origin, "/api/folders", { key });
+  if (probe3.status === 401 || probe3.status === 403) {
+    throw new Error(apiError("validate key", probe3));
   }
   const path = writeCredential(key);
   r.done(
@@ -8813,20 +8818,1354 @@ async function cmdDelete(argv) {
   return EXIT_OK;
 }
 
-// src/plugin/recipe.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { basename as basename6 } from "path";
+// src/plugin/buildProgram.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename6, dirname as dirname5, join as join19, resolve as resolve7 } from "path";
+import { pathToFileURL } from "url";
+import { parse } from "acorn";
+import { fullAncestor } from "acorn-walk";
+var FUNCTION_KEYS = [
+  "setup",
+  "createContent",
+  "createTimeline",
+  "onFrame",
+  "retime"
+];
+var PAGE_GLOBALS = /* @__PURE__ */ new Set([
+  "window",
+  "document",
+  "navigator",
+  "location",
+  "performance",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "devicePixelRatio",
+  "Image",
+  "ImageData",
+  "ImageBitmap",
+  "createImageBitmap",
+  "OffscreenCanvas",
+  "HTMLCanvasElement",
+  "CanvasRenderingContext2D",
+  "Path2D",
+  "DOMMatrix",
+  "FontFace",
+  "Blob",
+  "URL",
+  "fetch",
+  "Response",
+  "TextEncoder",
+  "TextDecoder",
+  "AudioContext",
+  "OfflineAudioContext",
+  "getComputedStyle",
+  "matchMedia",
+  "atob",
+  "btoa"
+]);
+var JS_GLOBALS = new Set(Object.getOwnPropertyNames(globalThis));
+JS_GLOBALS.add("undefined");
+JS_GLOBALS.add("arguments");
+function functionSource(fn) {
+  const src = fn.toString();
+  if (parsesAsExpression(src)) return src;
+  const asyncMethod = /^async\s+/.test(src);
+  const body = asyncMethod ? src.replace(/^async\s+/, "") : src;
+  const candidate = `${asyncMethod ? "async " : ""}function ${body}`;
+  if (parsesAsExpression(candidate)) return candidate;
+  return src;
+}
+function parsesAsExpression(src) {
+  try {
+    parse(`(${src})`, { ecmaVersion: "latest" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function freeIdentifiers(src) {
+  const ast = parse(`(${src})`, { ecmaVersion: "latest" });
+  const declared = /* @__PURE__ */ new Set();
+  const read = /* @__PURE__ */ new Set();
+  const addPattern = (p) => {
+    if (!p) return;
+    if (p.type === "Identifier") declared.add(p.name);
+    else if (p.type === "ObjectPattern")
+      for (const prop of p.properties)
+        addPattern(prop.type === "RestElement" ? prop.argument : prop.value);
+    else if (p.type === "ArrayPattern")
+      for (const el of p.elements) addPattern(el);
+    else if (p.type === "RestElement") addPattern(p.argument);
+    else if (p.type === "AssignmentPattern") addPattern(p.left);
+  };
+  fullAncestor(ast, (node, _state, ancestors) => {
+    if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+      if (node.id) declared.add(node.id.name);
+      for (const p of node.params) addPattern(p);
+    } else if (node.type === "VariableDeclarator") addPattern(node.id);
+    else if (node.type === "ClassDeclaration" && node.id)
+      declared.add(node.id.name);
+    else if (node.type === "CatchClause") addPattern(node.param);
+    else if (node.type === "Identifier") {
+      const parent = ancestors[ancestors.length - 2];
+      if (!parent) return;
+      if (parent.type === "MemberExpression" && parent.property === node && !parent.computed)
+        return;
+      if ((parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") && parent.key === node && !parent.computed && !(parent.type === "Property" && parent.shorthand))
+        return;
+      if (parent.type === "LabeledStatement" || parent.type === "BreakStatement" || parent.type === "ContinueStatement")
+        return;
+      if (parent.type === "MetaProperty") return;
+      read.add(node.name);
+    }
+  });
+  return [...read].filter(
+    (n) => !declared.has(n) && !JS_GLOBALS.has(n) && !PAGE_GLOBALS.has(n)
+  ).sort();
+}
+function buildProgram(program, file, text) {
+  const problems = [];
+  const sources = {};
+  const stringify = (fn, name) => {
+    if (fn === void 0) return void 0;
+    if (typeof fn === "string") return fn;
+    if (typeof fn !== "function") {
+      problems.push({
+        fn: name,
+        message: `must be a function, got ${typeof fn}`
+      });
+      return void 0;
+    }
+    const raw = fn.toString();
+    const src = functionSource(fn);
+    const at2 = text.indexOf(raw);
+    sources[name] = at2 >= 0 ? { file, line: text.slice(0, at2).split("\n").length } : null;
+    let free;
+    try {
+      free = freeIdentifiers(src);
+    } catch (e) {
+      problems.push({
+        fn: name,
+        message: `does not parse as JavaScript the page can run: ${e.message}`
+      });
+      return src;
+    }
+    for (const n of free) {
+      problems.push({
+        fn: name,
+        message: `reads \`${n}\` from outside the function; the string travels without it. Move it inside the function, or put its value in data and read ctx.data.`
+      });
+    }
+    return src;
+  };
+  const out = {};
+  for (const [key, value] of Object.entries(program)) {
+    if (FUNCTION_KEYS.includes(key)) {
+      const s = stringify(value, key);
+      if (s !== void 0) out[key] = s;
+    } else if (key === "stack" && Array.isArray(value)) {
+      out.stack = value.map((entry, i) => {
+        const e = { ...entry };
+        for (const k of FUNCTION_KEYS) {
+          if (k in e) {
+            const s = stringify(e[k], `stack[${String(entry.id ?? i)}].${k}`);
+            if (s !== void 0) e[k] = s;
+          }
+        }
+        return e;
+      });
+    } else {
+      out[key] = value;
+    }
+  }
+  for (const key of Object.keys(out)) {
+    if (FUNCTION_KEYS.includes(key) || key === "stack")
+      continue;
+    const bad = nonJson(out[key], key);
+    if (bad) problems.push({ fn: key, message: bad });
+  }
+  return { config: out, sources, problems };
+}
+function nonJson(value, path) {
+  if (value === null) return null;
+  const t = typeof value;
+  if (t === "function")
+    return `${path} is a function; only the hooks (${FUNCTION_KEYS.join(", ")}) may be`;
+  if (t === "number" && !Number.isFinite(value))
+    return `${path} is ${String(value)}, which JSON cannot carry`;
+  if (t === "undefined" || t === "symbol" || t === "bigint")
+    return `${path} is ${t}, which JSON cannot carry`;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const r = nonJson(value[i], `${path}[${i}]`);
+      if (r) return r;
+    }
+    return null;
+  }
+  if (t === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null)
+      return `${path} is a ${proto?.constructor?.name ?? "class"} instance; use plain objects and arrays`;
+    for (const [k, v] of Object.entries(value)) {
+      const r = nonJson(v, `${path}.${k}`);
+      if (r) return r;
+    }
+  }
+  return null;
+}
 var BOOLEAN_FLAGS5 = /* @__PURE__ */ new Set(["json", "help"]);
+async function cmdBuild(argv) {
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS5);
+  const source = positionals[0];
+  if (!source)
+    throw new UsageError("vos build <program.mjs> [--out config.json] [--json]");
+  const r = createReporter(flags.json === true);
+  const file = resolve7(source);
+  const text = readFileSync4(file, "utf8");
+  const mod = await import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+  const program = mod.default ?? mod.program;
+  if (!program || typeof program !== "object")
+    throw new UsageError(
+      `${source} exports no program: \`export default { version: 2, duration, camera, createContent, createTimeline, \u2026 }\``
+    );
+  const built = buildProgram(program, basename6(file), text);
+  for (const p of built.problems) r.log(`error ${p.fn}: ${p.message}`);
+  if (built.problems.length) {
+    r.done(
+      { ok: false, problems: built.problems },
+      `${source}: ${built.problems.length} problem${built.problems.length === 1 ? "" : "s"}, nothing written`
+    );
+    return EXIT_ERROR;
+  }
+  const out = resolve7(
+    strFlag(flags, "out") ?? join19(dirname5(file), "config.json")
+  );
+  writeFileSync2(out, JSON.stringify(built.config, null, 2) + "\n");
+  const sidecar = out.replace(/\.json$/, "") + ".sources.json";
+  writeFileSync2(sidecar, JSON.stringify(built.sources, null, 2) + "\n");
+  for (const [fn, at2] of Object.entries(built.sources)) {
+    if (at2) r.log(`  ${fn} \u2192 ${at2.file}:${at2.line}`);
+  }
+  r.done(
+    { ok: true, out, sources: sidecar, functions: Object.keys(built.sources) },
+    `Wrote ${out} (${Object.keys(built.sources).length} functions; an engine error at fn:N is that function's line N, from the line above)`
+  );
+  return EXIT_OK;
+}
+
+// src/plugin/compare.ts
+import { spawnSync } from "child_process";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join20, resolve as resolve8 } from "path";
+var BOOLEAN_FLAGS6 = /* @__PURE__ */ new Set(["json", "help"]);
+function sampleTimes(duration, every) {
+  const step = every > 0 ? every : 1;
+  const out = [];
+  for (let t = step / 2; t < duration; t += step) out.push(Number(t.toFixed(3)));
+  return out.length ? out : [Number((duration / 2).toFixed(3))];
+}
+function parseSsim(stderr) {
+  const m = /All:([0-9.]+)/.exec(stderr);
+  return m ? Number(m[1]) : null;
+}
+function compareVerdict(scores, threshold) {
+  const values = scores.map((s) => s.ssim);
+  const min = values.length ? Math.min(...values) : 0;
+  const mean = values.length ? values.reduce((a, b) => a + b, 0) / values.length : 0;
+  const failing = scores.filter((s) => s.ssim < threshold).map((s) => s.t);
+  return { min, mean, failing, pass: failing.length === 0 && values.length > 0 };
+}
+function ffmpeg(args) {
+  const res = spawnSync("ffmpeg", ["-hide_banner", ...args], {
+    encoding: "utf8"
+  });
+  return { ok: res.status === 0, stderr: res.stderr ?? "" };
+}
+function requireFfmpeg() {
+  const res = spawnSync("ffmpeg", ["-version"], { encoding: "utf8" });
+  if (res.status !== 0)
+    throw new UsageError(
+      "vos compare reads frames with ffmpeg, and none is on PATH: install it (brew install ffmpeg, apt install ffmpeg) and run again"
+    );
+}
+function probeSize(video) {
+  const res = spawnSync(
+    "ffprobe",
+    [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-show_entries",
+      "stream=width,height",
+      "-of",
+      "csv=p=0",
+      video
+    ],
+    { encoding: "utf8" }
+  );
+  const m = /(\d+),(\d+)/.exec(res.stdout ?? "");
+  return m ? { width: Number(m[1]), height: Number(m[2]) } : null;
+}
+async function cmdCompare(argv) {
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS6);
+  const source = positionals[0];
+  const against = strFlag(flags, "against");
+  if (!source || !against)
+    throw new UsageError(
+      "vos compare <program dir|config.json> --against <their render.mp4> [--times a,b,50%] [--every 1] [--width W --height H] [--threshold 0.95] [--out compare] [--json]"
+    );
+  requireFfmpeg();
+  const r = createReporter(flags.json === true);
+  const ref = resolve8(against);
+  const loaded = await loadVosConfig(source);
+  for (const w of loaded.warnings) r.log(`note: ${w}`);
+  const config = loaded.config;
+  const duration = configDuration(config) ?? 5;
+  const probed = probeSize(ref);
+  const half = probed && probed.width > 1280 ? 2 : 1;
+  const width = Number(
+    strFlag(flags, "width") ?? (probed ? probed.width / half : 960)
+  );
+  const height = Number(
+    strFlag(flags, "height") ?? (probed ? probed.height / half : 540)
+  );
+  const threshold = Number(strFlag(flags, "threshold") ?? 0.95);
+  const timesRaw = strFlag(flags, "times");
+  const times = timesRaw ? parseTimes(timesRaw, duration) : sampleTimes(duration, Number(strFlag(flags, "every") ?? 1));
+  const outDir = resolve8(strFlag(flags, "out") ?? "compare");
+  mkdirSync2(outDir, { recursive: true });
+  const browser = await launchBrowser();
+  const scores = [];
+  try {
+    for (const t of times) {
+      const tag = t.toFixed(2);
+      const refPng = join20(outDir, `src-${tag}.png`);
+      const vosPng = join20(outDir, `vos-${tag}.png`);
+      const sheet = join20(outDir, `sheet-${tag}.png`);
+      const grab = ffmpeg([
+        "-v",
+        "error",
+        "-y",
+        "-ss",
+        String(t),
+        "-i",
+        ref,
+        "-frames:v",
+        "1",
+        "-vf",
+        `scale=${width}:${height}`,
+        refPng
+      ]);
+      if (!grab.ok)
+        throw new Error(
+          `could not read ${against} at ${tag}s: ${grab.stderr.trim()}`
+        );
+      const still = await renderStill(browser, {
+        config,
+        width,
+        height,
+        time: t
+      });
+      writeFileSync3(vosPng, await reencodeStill(browser, still.bytes, "png"));
+      const pair = ["-i", refPng, "-i", vosPng];
+      const ssim = parseSsim(
+        ffmpeg([
+          ...pair,
+          "-lavfi",
+          "[0:v]format=rgb24[x];[1:v]format=rgb24[y];[x][y]ssim",
+          "-f",
+          "null",
+          "-"
+        ]).stderr
+      );
+      ffmpeg([
+        "-v",
+        "error",
+        "-y",
+        ...pair,
+        "-filter_complex",
+        "[0:v]format=gbrp[x];[1:v]format=gbrp[y];[x]split[x1][x2];[y]split[y1][y2];[x1][y1]blend=all_mode=difference[d];[x2][y2][d]hstack=inputs=3,format=rgb24",
+        sheet
+      ]);
+      const score = { t, ssim: ssim ?? 0, sheet };
+      scores.push(score);
+      const mark = score.ssim < threshold ? "  \u2190 under" : "";
+      r.log(`t=${tag}s  SSIM ${score.ssim.toFixed(3)}  ${sheet}${mark}`);
+      for (const w of still.pageErrors)
+        r.log(`warn: t=${tag}s the page threw: ${w}`);
+    }
+  } finally {
+    await browser.close();
+  }
+  const overview = join20(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(";");
+    const stack = scores.map((_, i) => `[s${i}]`).join("");
+    ffmpeg([
+      "-v",
+      "error",
+      "-y",
+      ...inputs,
+      "-filter_complex",
+      scores.length > 1 ? `${scaled};${stack}vstack=inputs=${scores.length}` : `${scaled}`.replace("[s0]", ""),
+      overview
+    ]);
+  }
+  const verdict = compareVerdict(scores, threshold);
+  const report = {
+    against: ref,
+    width,
+    height,
+    threshold,
+    ...verdict,
+    frames: scores,
+    overview
+  };
+  writeFileSync3(
+    join20(outDir, "report.json"),
+    JSON.stringify(report, null, 2) + "\n"
+  );
+  r.done(
+    report,
+    `${scores.length} frames: mean SSIM ${verdict.mean.toFixed(3)}, lowest ${verdict.min.toFixed(3)}${verdict.failing.length ? `; under ${threshold} at ${verdict.failing.map((t) => `${t}s`).join(", ")}: look at those sheets` : `; every frame at or above ${threshold}`}. Sheets (source | vos | difference) and overview.png in ${outDir}`
+  );
+  return verdict.pass ? EXIT_OK : EXIT_ERROR;
+}
+
+// src/plugin/port.ts
+import { existsSync as existsSync19, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname8, join as join23, resolve as resolve11 } from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+
+// src/plugin/portInventory.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import {
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync4,
+  statSync as statSync5
+} from "fs";
+import { basename as basename7, dirname as dirname6, join as join21, relative as relative2, resolve as resolve9 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import { findFontFamily as findFontFamily3 } from "@vosjs/shared";
+function detectEngine(dir) {
+  if (existsSync17(join21(dir, "hyperframes.json"))) return "hyperframes";
+  const pkg = join21(dir, "package.json");
+  if (existsSync17(pkg)) {
+    try {
+      const p = JSON.parse(readFileSync5(pkg, "utf8"));
+      const deps = { ...p.dependencies ?? {}, ...p.devDependencies ?? {} };
+      if ("remotion" in deps) return "remotion";
+      if ("hyperframes" in deps) return "hyperframes";
+      if (/hyperframes/.test(JSON.stringify(p.scripts ?? {})))
+        return "hyperframes";
+    } catch {
+    }
+  }
+  return "page";
+}
+function sourcePage(source) {
+  if (!existsSync17(source)) return null;
+  if (statSync5(source).isFile()) return /\.html?$/i.test(source) ? source : null;
+  const index = join21(source, "index.html");
+  return existsSync17(index) ? index : null;
+}
+function findRender(dir) {
+  const videos = (d) => existsSync17(d) ? readdirSync4(d).filter((f) => /\.(mp4|webm|mov)$/i.test(f)).map((f) => join21(d, f)) : [];
+  for (const d of [join21(dir, "renders"), join21(dir, "out"), dir]) {
+    const found = videos(d);
+    if (found.length) return found[0];
+  }
+  return null;
+}
+function scriptStringsOf(code) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of code.matchAll(/(['"`])((?:(?!\1)[^\\\n]|\\.){2,60})\1/g)) {
+    const s = m[2];
+    if (!/[A-Za-z]{2}/.test(s)) continue;
+    if (/["'`]/.test(s)) continue;
+    if (/\b[a-zA-Z_$][\w$]*\s*:\s*[\w$.]+\s*,/.test(s)) continue;
+    if (/^-?[\d.]+(px|%|ms|s|deg|em|rem|vh|vw)?$/.test(s)) continue;
+    if (/^[a-z]+\/[a-z0-9.+-]+$/.test(s)) continue;
+    if (/^(source|destination)-(over|in|out|atop)$|^(lighter|copy|xor|multiply|screen|overlay|darken|lighten|difference|exclusion)$/.test(
+      s
+    ))
+      continue;
+    if (/^[A-Za-z ]{4}$/.test(s) && /^(RIFF|WAVE|fmt |data|LIST)$/.test(s))
+      continue;
+    if (/[(){};=<>]|\$\{|^\.?\/|https?:|\.(js|css|png|jpe?g|mp[34]|wav|woff2?)$/i.test(
+      s
+    ))
+      continue;
+    if (/^[a-z][a-zA-Z0-9]*$/.test(s) && !/[A-Z]{2}/.test(s)) continue;
+    if (/^(rgba?|hsla?)\(|^#[0-9a-f]{3,8}$/i.test(s)) continue;
+    out.add(s);
+  }
+  return [...out].slice(0, 80);
+}
+function scriptScenes(ids, code, duration) {
+  const found = /* @__PURE__ */ new Map();
+  for (const id of ids) {
+    const re = new RegExp(
+      `\\.(?:set|to|fromTo)\\(\\s*["'\`]#${id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'\`][^)]*?(?:opacity|autoAlpha)\\s*:\\s*1[^)]*?,\\s*([\\d.]+)\\s*\\)`
+    );
+    const m = re.exec(code);
+    if (m) found.set(id, Number(m[1]));
+    else if (!found.size && ids[0] === id) found.set(id, 0);
+  }
+  for (const m of code.matchAll(
+    /addLabel\(\s*["'`]([^"'`]+)["'`]\s*,\s*([\d.]+)/g
+  )) {
+    if (!found.has(m[1])) found.set(m[1], Number(m[2]));
+  }
+  const sorted = [...found.entries()].sort((a, b) => a[1] - b[1]);
+  return sorted.map(([name, start], i) => {
+    const next = sorted[i + 1]?.[1] ?? duration;
+    return {
+      name,
+      start,
+      duration: next == null ? null : Math.round((next - start) * 1e3) / 1e3
+    };
+  });
+}
+function scriptFontFamilies(code) {
+  const out = /* @__PURE__ */ new Set();
+  const generic = /,\s*(?:sans-serif|serif|monospace|cursive|system-ui)\b/;
+  const shorthand = /^(?:(?:italic|oblique|normal|bold|bolder|lighter|small-caps|\d{3})\s+)*[\d.]+(?:px|pt|em|rem|%)(?:\/[\d.]+\w*)?\s+/;
+  for (const m of code.matchAll(/(['"`])((?:\\.|(?!\1).)*?)\1/g)) {
+    const s = m[2];
+    if (!generic.test(s)) continue;
+    const first = s.replace(shorthand, "").split(",")[0].trim().replace(/^["']|["']$/g, "");
+    if (first && !/^(sans-serif|serif|monospace|cursive|system-ui)$/.test(first))
+      out.add(first);
+  }
+  return [...out];
+}
+function catalogFamily2(family) {
+  const clean = family.trim().replace(/^['"]|['"]$/g, "");
+  return findFontFamily3(clean)?.family ?? null;
+}
+function probe(video) {
+  const res = spawnSync2(
+    "ffprobe",
+    [
+      "-v",
+      "error",
+      "-select_streams",
+      "v:0",
+      "-show_entries",
+      "stream=r_frame_rate:format=duration",
+      "-of",
+      "json",
+      video
+    ],
+    { encoding: "utf8" }
+  );
+  try {
+    const j = JSON.parse(res.stdout ?? "{}");
+    const [n, d] = String(j.streams?.[0]?.r_frame_rate ?? "").split("/").map(Number);
+    const fps = n && d ? Math.round(n / d * 100) / 100 : null;
+    const duration = Number(j.format?.duration);
+    return { fps, duration: Number.isFinite(duration) ? duration : null };
+  } catch {
+    return { fps: null, duration: null };
+  }
+}
+var READ_PAGE = `(() => {
+  const root = document.querySelector('[data-composition-id], [data-width][data-height]') || document.body
+  const num = (v) => { const n = Number(v); return Number.isFinite(n) ? n : null }
+  const canvases = [...document.querySelectorAll('canvas')].map((c) => ({ width: c.width, height: c.height }))
+  const biggest = canvases.slice().sort((a, b) => b.width * b.height - a.width * a.height)[0]
+  const width = num(root.dataset && root.dataset.width) || (biggest && biggest.width) || window.innerWidth
+  const height = num(root.dataset && root.dataset.height) || (biggest && biggest.height) || window.innerHeight
+  const rootRect = root.getBoundingClientRect()
+  const sx = rootRect.width ? width / rootRect.width : 1
+  const sy = rootRect.height ? height / rootRect.height : 1
+
+  const texts = []
+  const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT)
+  const seen = new Set()
+  let n = 0
+  while (walker.nextNode()) {
+    const node = walker.currentNode
+    const text = (node.textContent || '').replace(/\\s+/g, ' ').trim()
+    const el = node.parentElement
+    if (!text || !el || ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TITLE'].includes(el.tagName)) continue
+    if (seen.has(el)) continue
+    seen.add(el)
+    const cs = getComputedStyle(el)
+    const r = el.getBoundingClientRect()
+    const box = r.width && r.height ? {
+      x: Math.round((r.left - rootRect.left) * sx), y: Math.round((r.top - rootRect.top) * sy),
+      width: Math.round(r.width * sx), height: Math.round(r.height * sy) } : null
+    const ls = parseFloat(cs.letterSpacing)
+    el.setAttribute('data-vos-inv', String(texts.length))
+    const sceneEl = el.closest('.scene, [data-scene], section[id]')
+    texts.push({
+      id: el.id || (el.className && typeof el.className === 'string' ? el.className.split(' ')[0] : '') || el.tagName.toLowerCase() + '-' + (n++),
+      text, tag: el.tagName.toLowerCase(), box, scene: sceneEl && sceneEl.id ? sceneEl.id : null,
+      font: { family: cs.fontFamily.split(',')[0].trim().replace(/^["']|["']$/g, ''),
+        size: Math.round(parseFloat(cs.fontSize) * sy), weight: Number(cs.fontWeight) || 400,
+        style: cs.fontStyle, color: cs.color, letterSpacing: Number.isFinite(ls) ? Math.round(ls * sy * 100) / 100 : 0,
+        transform: cs.textTransform },
+    })
+  }
+
+  const palette = {}
+  const isColor = (v) => /^(#[0-9a-f]{3,8}|rgba?\\(|hsla?\\(|oklch\\()/i.test(v)
+  const scan = (style) => { for (let i = 0; i < style.length; i++) { const p = style[i]; if (p.startsWith('--')) { const v = style.getPropertyValue(p).trim(); if (isColor(v)) palette[p.slice(2)] = v } } }
+  for (const sheet of document.styleSheets) {
+    let rules
+    try { rules = sheet.cssRules } catch (e) { continue }
+    for (const rule of rules) if (rule.style) scan(rule.style)
+  }
+  scan(root.style)
+
+  const colors = new Set()
+  const gaps = new Set()
+  for (const el of document.querySelectorAll('body *')) {
+    const cs = getComputedStyle(el)
+    if (cs.backgroundColor && cs.backgroundColor !== 'rgba(0, 0, 0, 0)') colors.add(cs.backgroundColor)
+    if (cs.mixBlendMode && cs.mixBlendMode !== 'normal') gaps.add('mix-blend-mode: ' + cs.mixBlendMode)
+    if (cs.clipPath && cs.clipPath !== 'none') gaps.add('clip-path')
+    if (cs.maskImage && cs.maskImage !== 'none') gaps.add('mask')
+    if (cs.overflow === 'hidden' && el.children.length && el.textContent.trim()) gaps.add('overflow: hidden (a text mask)')
+    if (cs.filter && cs.filter !== 'none') gaps.add('filter: ' + cs.filter.split('(')[0])
+    if (cs.backdropFilter && cs.backdropFilter !== 'none') gaps.add('backdrop-filter')
+    if (cs.perspective && cs.perspective !== 'none') gaps.add('3D perspective')
+    if (cs.webkitTextStrokeWidth && parseFloat(cs.webkitTextStrokeWidth) > 0) gaps.add('-webkit-text-stroke (a stroke: see the reference for its width)')
+  }
+  for (const t of texts) colors.add(t.font.color)
+
+  const media = []
+  const attrs = (el) => ({ start: num(el.dataset.start), duration: num(el.dataset.duration), volume: num(el.dataset.volume), mediaStart: num(el.dataset.mediaStart) })
+  for (const el of document.querySelectorAll('img')) media.push({ kind: 'image', src: el.getAttribute('src'), ...attrs(el) })
+  for (const el of document.querySelectorAll('svg')) if (!el.closest('svg svg')) media.push({ kind: 'svg', src: null, ...attrs(el) })
+  for (const el of document.querySelectorAll('video')) media.push({ kind: 'video', src: el.getAttribute('src') || (el.querySelector('source') && el.querySelector('source').getAttribute('src')), ...attrs(el) })
+  for (const el of document.querySelectorAll('audio')) media.push({ kind: 'audio', src: el.getAttribute('src') || (el.querySelector('source') && el.querySelector('source').getAttribute('src')), ...attrs(el) })
+
+  const scenes = []
+  for (const el of document.querySelectorAll('[data-start]')) {
+    if (['AUDIO', 'VIDEO', 'IMG'].includes(el.tagName)) continue
+    scenes.push({ name: el.id || el.dataset.compositionId || (typeof el.className === 'string' ? el.className.split(' ')[0] : '') || el.tagName.toLowerCase(), start: num(el.dataset.start) || 0, duration: num(el.dataset.duration) })
+  }
+  const sceneEls = [...document.querySelectorAll('.scene, [data-scene], section[id]')]
+    .filter((el) => el.id)
+    .map((el) => el.id)
+  let variables = {}
+  try { variables = JSON.parse(root.dataset.compositionVariables || '{}') } catch (e) {}
+  const scriptText = [...document.querySelectorAll('script:not([src])')].map((s) => s.textContent).join('\\n')
+  return {
+    width, height, fps: num(root.dataset && root.dataset.fps), duration: num(root.dataset && root.dataset.duration),
+    texts, palette, colors: [...colors], gaps: [...gaps], media, canvases, scenes, sceneEls, variables, scriptText,
+  }
+})()`;
+var SEEK_AND_READ = `((args) => {
+  const tls = window.__timelines ? Object.values(window.__timelines) : []
+  if (!tls.length) return null
+  for (const tl of tls) { try { tl.pause(); tl.seek(args.t, false) } catch (e) {} }
+  const root = document.querySelector('[data-composition-id], [data-width][data-height]') || document.body
+  const rr = root.getBoundingClientRect()
+  const sx = rr.width ? args.width / rr.width : 1
+  const sy = rr.height ? args.height / rr.height : 1
+  const out = {}
+  for (const i of args.indices) {
+    const el = document.querySelector('[data-vos-inv="' + i + '"]')
+    if (!el) continue
+    const r = el.getBoundingClientRect()
+    if (r.width && r.height) out[i] = { x: Math.round((r.left - rr.left) * sx), y: Math.round((r.top - rr.top) * sy), width: Math.round(r.width * sx), height: Math.round(r.height * sy) }
+  }
+  return out
+})`;
+async function readInventory(source, opts) {
+  const abs = resolve9(source);
+  const dir = existsSync17(abs) && statSync5(abs).isDirectory() ? abs : dirname6(abs);
+  const engine = detectEngine(dir);
+  const page = sourcePage(abs);
+  const render = opts.render === void 0 ? findRender(dir) : opts.render;
+  let read = {
+    width: 1920,
+    height: 1080,
+    fps: null,
+    duration: null,
+    texts: [],
+    palette: {},
+    colors: [],
+    gaps: [],
+    media: [],
+    canvases: [],
+    scenes: [],
+    variables: {},
+    scriptText: ""
+  };
+  const fromRender = render ? probe(render) : { fps: null, duration: null };
+  let fps = fromRender.fps;
+  let duration = fromRender.duration;
+  let settled = 0;
+  if (page) {
+    const browser = await launchBrowser();
+    try {
+      const ctx = await browser.newContext({
+        viewport: { width: 1920, height: 1080 }
+      });
+      const p = await ctx.newPage();
+      await p.addInitScript("window.__timelines = window.__timelines || {}");
+      await p.goto(pathToFileURL2(page).href, { waitUntil: "load" });
+      await p.evaluate("document.fonts && document.fonts.ready");
+      await p.waitForTimeout(300);
+      read = await p.evaluate(READ_PAGE);
+      fps = read.fps ?? fps;
+      duration = read.duration ?? duration;
+      const scripted = scriptScenes(
+        read.sceneEls ?? [],
+        read.scriptText ?? "",
+        duration
+      );
+      if (scripted.length > (read.scenes?.length ?? 0)) read.scenes = scripted;
+      for (const s of read.scenes) {
+        const indices = read.texts.map((t2, i) => t2.scene === s.name ? i : -1).filter((i) => i >= 0);
+        if (!indices.length) continue;
+        const t = s.start + (s.duration ?? 1) * 0.75;
+        const boxes = await p.evaluate(
+          `${SEEK_AND_READ}(${JSON.stringify({ t, indices, width: read.width, height: read.height })})`
+        );
+        if (!boxes) break;
+        for (const [i, box] of Object.entries(boxes)) {
+          read.texts[Number(i)].box = box;
+          settled++;
+        }
+      }
+      await ctx.close();
+    } finally {
+      await browser.close();
+    }
+  } else if (engine === "remotion") {
+    opts.log?.(
+      "a Remotion project: its words and colours live in its source (src/), which the agent reads; the inventory records the render and its stills"
+    );
+  }
+  if (settled)
+    opts.log?.(
+      `${settled} words laid out where they settle in their scene (the piece's own timelines, seeked)`
+    );
+  const families = /* @__PURE__ */ new Map();
+  for (const t of read.texts) {
+    const f = families.get(t.font.family) ?? {
+      family: t.font.family,
+      weights: [],
+      italic: false,
+      catalog: catalogFamily2(t.font.family)
+    };
+    if (!f.weights.includes(t.font.weight)) f.weights.push(t.font.weight);
+    if (t.font.style === "italic") f.italic = true;
+    families.set(t.font.family, f);
+  }
+  for (const family of scriptFontFamilies(read.scriptText ?? "")) {
+    if (!families.has(family))
+      families.set(family, {
+        family,
+        weights: [],
+        italic: false,
+        catalog: catalogFamily2(family)
+      });
+  }
+  const stills = [];
+  if (render && duration) {
+    const has = spawnSync2("ffmpeg", ["-version"]).status === 0;
+    if (has) {
+      const refDir = join21(opts.outDir, "ref");
+      mkdirSync3(refDir, { recursive: true });
+      const times = read.scenes.length >= 3 ? read.scenes.map(
+        (s) => s.start + (s.duration ?? 1) / 2
+      ) : Array.from(
+        { length: Math.max(1, Math.floor(duration)) },
+        (_, i) => i + 0.5
+      );
+      for (const t of times.filter((t2) => t2 < duration)) {
+        const file = join21(refDir, `src-${t.toFixed(2)}.png`);
+        const ok = spawnSync2("ffmpeg", [
+          "-v",
+          "error",
+          "-y",
+          "-ss",
+          String(t),
+          "-i",
+          render,
+          "-frames:v",
+          "1",
+          "-vf",
+          "scale=960:-2",
+          file
+        ]).status === 0;
+        if (ok)
+          stills.push({
+            t: Number(t.toFixed(2)),
+            file: relative2(opts.outDir, file)
+          });
+      }
+    } else {
+      opts.log?.(
+        "no ffmpeg on PATH: no reference stills (install it to get them)"
+      );
+    }
+  }
+  const scriptStrings = scriptStringsOf(read.scriptText);
+  return {
+    source: relative2(process.cwd(), abs) || basename7(abs),
+    engine,
+    width: read.width,
+    height: read.height,
+    fps,
+    duration,
+    scenes: read.scenes,
+    texts: read.texts,
+    palette: read.palette,
+    colors: read.colors,
+    fonts: [...families.values()],
+    media: read.media,
+    canvases: read.canvases,
+    gaps: read.gaps,
+    variables: read.variables,
+    scriptStrings,
+    render: render ? relative2(process.cwd(), render) : null,
+    stills
+  };
+}
+
+// src/plugin/portScaffold.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { copyFileSync, existsSync as existsSync18, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { basename as basename8, dirname as dirname7, join as join22, resolve as resolve10 } from "path";
+import { findFontFamily as findFontFamily4, fontFaceUrl, nearestFontWeight } from "@vosjs/shared";
+var DESIGN_HEIGHT = 1080;
+function toHex(css) {
+  const s = css.trim();
+  if (/^#[0-9a-f]{3,8}$/i.test(s)) {
+    if (s.length === 4)
+      return `#${[...s.slice(1)].map((c) => c + c).join("")}`.toLowerCase();
+    return s.toLowerCase();
+  }
+  const m = /^rgba?\(\s*([\d.]+)[,\s]+([\d.]+)[,\s]+([\d.]+)(?:[,/\s]+([\d.]+%?))?\s*\)$/i.exec(
+    s
+  );
+  if (!m) return s;
+  const hex2 = (v) => Math.round(Math.max(0, Math.min(255, v))).toString(16).padStart(2, "0");
+  let a = m[4] === void 0 ? 1 : m[4].endsWith("%") ? Number(m[4].slice(0, -1)) / 100 : Number(m[4]);
+  if (!Number.isFinite(a)) a = 1;
+  return `#${hex2(+m[1])}${hex2(+m[2])}${hex2(+m[3])}${a < 1 ? hex2(a * 255) : ""}`;
+}
+function keyFor(label, taken, prefix = "t") {
+  const words = label.replace(/[^A-Za-z0-9]+/g, " ").trim().split(" ").filter(Boolean).slice(0, 4);
+  let base = words.map(
+    (w, i) => i === 0 ? w.toLowerCase() : w[0].toUpperCase() + w.slice(1).toLowerCase()
+  ).join("");
+  if (!base || /^[0-9]/.test(base)) base = prefix + (base || "");
+  let key = base;
+  for (let n = 2; taken.has(key); n++) key = `${base}${n}`;
+  taken.add(key);
+  return key;
+}
+function substituteFamily(family) {
+  const f = family.toLowerCase();
+  if (/mono|code|courier/.test(f)) return "JetBrains Mono";
+  if (/serif/.test(f) && !/sans/.test(f)) return "Source Serif 4";
+  if (/condensed|compressed|black|anton|bebas|oswald/.test(f)) return "Anton";
+  return "Inter";
+}
+var fmtPct = (v) => `${Math.round(v * 1e4) / 100}%`;
+function planScaffold(inv, opts) {
+  const taken = /* @__PURE__ */ new Set(["scenes", "bg"]);
+  const data = {};
+  const report = [];
+  const scale = DESIGN_HEIGHT / (inv.height || DESIGN_HEIGHT);
+  const colorKey = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(inv.palette)) {
+    const key = keyFor(name, taken, "color");
+    const hex2 = toHex(value);
+    data[key] = hex2;
+    if (!colorKey.has(hex2)) colorKey.set(hex2, key);
+  }
+  const colorOf = (css) => {
+    const hex2 = toHex(css);
+    const known = colorKey.get(hex2);
+    if (known) return known;
+    const key = keyFor(`color ${colorKey.size + 1}`, taken, "color");
+    data[key] = hex2;
+    colorKey.set(hex2, key);
+    return key;
+  };
+  data.bg = inv.colors.length ? toHex(inv.colors[0]) : "#000000";
+  const faces = /* @__PURE__ */ new Map();
+  const faceFor = (t) => {
+    const hit = findFontFamily4(t.font.family);
+    const family = hit?.family ?? substituteFamily(t.font.family);
+    const face = faces.get(family) ?? {
+      family,
+      weights: /* @__PURE__ */ new Set(),
+      italic: false,
+      from: hit ? null : t.font.family
+    };
+    face.weights.add(t.font.weight);
+    if (t.font.style === "italic") face.italic = true;
+    faces.set(family, face);
+    return family;
+  };
+  const elements = [];
+  const textKeys = [];
+  const sceneNames = new Set(inv.scenes.map((s) => s.name));
+  const sceneElements = {};
+  for (const t of inv.texts) {
+    const generic = /^(div|span|p|h[1-6]|li|a|b|i|em|strong)-\d+$/.test(t.id);
+    const key = keyFor(generic ? t.text : t.id, taken);
+    const words = t.font.transform === "uppercase" ? t.text.toUpperCase() : t.font.transform === "lowercase" ? t.text.toLowerCase() : t.text;
+    data[key] = words;
+    const family = faceFor(t);
+    elements.push({
+      id: key,
+      type: "text",
+      content: { $data: key },
+      position: t.box ? { x: fmtPct(t.box.x / inv.width), y: fmtPct(t.box.y / inv.height) } : "center",
+      font: {
+        family,
+        size: Math.round(t.font.size * scale),
+        weight: t.font.weight,
+        ...t.font.style === "italic" ? { style: "italic" } : {},
+        color: { $data: colorOf(t.font.color) },
+        ...t.font.letterSpacing ? {
+          letterSpacing: Math.round(t.font.letterSpacing * scale * 10) / 10
+        } : {}
+      }
+    });
+    textKeys.push({ key, size: t.font.size, label: words.slice(0, 40) });
+    if (t.scene && sceneNames.has(t.scene))
+      (sceneElements[t.scene] ??= []).push(key);
+  }
+  const fonts = [];
+  for (const face of faces.values()) {
+    const entry = findFontFamily4(face.family);
+    if (!entry) continue;
+    for (const w of face.weights) {
+      const weight = nearestFontWeight(entry, w);
+      fonts.push({
+        family: entry.family,
+        weight,
+        url: fontFaceUrl(entry.slug, weight)
+      });
+    }
+    if (face.italic) {
+      const italics = entry.italics ?? [];
+      if (italics.length) {
+        const weight = italics.includes(400) ? 400 : italics[0];
+        fonts.push({
+          family: entry.family,
+          weight,
+          style: "italic",
+          url: fontFaceUrl(entry.slug, weight, "italic")
+        });
+      }
+    }
+  }
+  const painterFaces = [];
+  for (const f of inv.fonts) {
+    if (!f.catalog || faces.has(f.catalog)) continue;
+    const entry = findFontFamily4(f.catalog);
+    if (!entry) continue;
+    for (const weight of entry.weights)
+      fonts.push({
+        family: entry.family,
+        weight,
+        url: fontFaceUrl(entry.slug, weight)
+      });
+    for (const weight of entry.italics ?? [])
+      fonts.push({
+        family: entry.family,
+        weight,
+        style: "italic",
+        url: fontFaceUrl(entry.slug, weight, "italic")
+      });
+    painterFaces.push(entry.family);
+  }
+  for (const f of inv.fonts) {
+    if (!f.catalog && !faces.has(substituteFamily(f.family)) && !inv.texts.some((t) => t.font.family === f.family))
+      report.push(
+        `- **${f.family}** (named in the scripts) is not in the catalog: draw with ${substituteFamily(f.family)} and say so in the push note`
+      );
+  }
+  if (painterFaces.length)
+    report.push(
+      `- faces the scripts paint with, declared at every hosted weight for the painter: ${painterFaces.join(", ")}`
+    );
+  data.scenes = inv.scenes.map((s) => ({
+    name: s.name,
+    at: s.start,
+    until: s.duration == null ? null : Math.round((s.start + s.duration) * 1e3) / 1e3
+  }));
+  data.sceneElements = sceneElements;
+  const params = [];
+  const paletteKeys = [...colorKey.values()].slice(0, 6);
+  for (const key of paletteKeys)
+    params.push({
+      key,
+      label: key,
+      kind: "color",
+      default: data[key],
+      group: "Colours"
+    });
+  for (const t of [...textKeys].sort((a, b) => b.size - a.size)) {
+    if (params.length >= 12) break;
+    params.push({
+      key: t.key,
+      label: t.label,
+      kind: "text",
+      default: data[t.key],
+      group: "Words"
+    });
+  }
+  const presets = paletteKeys.length ? [
+    {
+      name: "Original",
+      values: Object.fromEntries(paletteKeys.map((k) => [k, data[k]]))
+    }
+  ] : [];
+  const painter = inv.canvases.length > 0 || inv.gaps.length > 0;
+  const duration = Math.round((inv.duration ?? 5) * 1e3) / 1e3;
+  const program = programSource({
+    source: inv.source,
+    duration,
+    data,
+    params,
+    presets,
+    fonts,
+    elements,
+    scenes: inv.scenes,
+    painter
+  });
+  const audio = [];
+  const copies = [];
+  inv.media.filter((m) => m.kind === "audio" && m.src).forEach((m, i) => {
+    const from = resolve10(opts.sourceDir, m.src);
+    const name = basename8(from);
+    if (!existsSync18(from)) {
+      report.push(
+        `- the audio ${m.src} is not in the source folder; add it to doc.json by hand`
+      );
+      return;
+    }
+    copies.push([from, name]);
+    const fileDuration = opts.probeDuration?.(from) ?? m.duration ?? duration;
+    audio.push({
+      id: `score${i ? i + 1 : ""}`,
+      key: name,
+      name,
+      start: m.start ?? 0,
+      in: m.mediaStart ?? 0,
+      out: Math.min(
+        fileDuration,
+        (m.mediaStart ?? 0) + (m.duration ?? fileDuration)
+      ),
+      duration: fileDuration,
+      gain: m.volume ?? 1,
+      fadeIn: 0,
+      fadeOut: 0
+    });
+  });
+  const short = Math.min(inv.width, inv.height);
+  const doc = {
+    program: {},
+    audio,
+    export: {
+      resolution: short >= 2160 ? "4k" : short >= 1440 ? "2k" : short >= 1080 ? "1080p" : "720p",
+      fps: (inv.fps ?? 30) >= 50 ? 60 : 30,
+      format: "mp4"
+    }
+  };
+  return {
+    program,
+    doc,
+    copies,
+    report: reportText(inv, {
+      faces: [...faces.values()],
+      elements: elements.length,
+      params: params.length,
+      painter,
+      extra: report
+    })
+  };
+}
+function programSource(p) {
+  const j = (v) => JSON.stringify(v, null, 2).replace(/\n/g, "\n  ");
+  const sceneTodos = p.scenes.length ? p.scenes.map(
+    (s) => `    // TODO scene "${s.name}" (${s.start}s${s.duration ? ` to ${s.start + s.duration}s` : ""}): translate its motion onto ctx.elements.get(id).props / .segments here`
+  ).join("\n") : "    // TODO: translate the source's motion here, one block per scene (tl.addLabel above names them)";
+  const painterContent = p.painter ? `
+    // THE PAINTER (vos-port rule 6): one canvas, only for what no element can
+    // say (the inventory's gaps and canvases). It reads every value from
+    // ctx.data. Its plane sits above the elements; move its renderOrder
+    // between two of them to paint between (SKILL.md "Layering").
+    const T = ctx.THREE
+    const canvas = document.createElement('canvas')
+    canvas.width = ctx.resolution.width
+    canvas.height = ctx.resolution.height
+    const tex = new T.CanvasTexture(canvas)
+    tex.colorSpace = T.SRGBColorSpace
+    const plane = new T.Mesh(
+      new T.PlaneGeometry(1, 1),
+      new T.MeshBasicMaterial({ map: tex, transparent: true, depthTest: false, depthWrite: false }),
+    )
+    plane.scale.set(ctx.resolution.width, ctx.resolution.height, 1)
+    plane.renderOrder = 100.995
+    plane.frustumCulled = false
+    ctx.overlayScene.add(plane)
+    // The starter's helpers: Remotion's interpolate, a seeded PRNG, smooth noise.
+    const clamp01 = (v) => (v < 0 ? 0 : v > 1 ? 1 : v)
+    const interpolate = (v, [a, b], [x, y], ease = (t) => t) =>
+      x + (y - x) * ease(clamp01((v - a) / (b - a)))
+    const rand = (seed) => () => {
+      seed |= 0
+      seed = (seed + 0x6d2b79f5) | 0
+      let r = Math.imul(seed ^ (seed >>> 15), 1 | seed)
+      r = (r + Math.imul(r ^ (r >>> 7), 61 | r)) ^ r
+      return ((r ^ (r >>> 14)) >>> 0) / 4294967296
+    }
+    const hash = (x, y) => {
+      const s = Math.sin(x * 127.1 + y * 311.7) * 43758.5453
+      return s - Math.floor(s)
+    }
+    const noise2 = (x, y) => {
+      const xi = Math.floor(x), yi = Math.floor(y)
+      const xf = x - xi, yf = y - yi
+      const u = xf * xf * (3 - 2 * xf), v = yf * yf * (3 - 2 * yf)
+      const a = hash(xi, yi), b = hash(xi + 1, yi), c = hash(xi, yi + 1), d = hash(xi + 1, yi + 1)
+      return (a + (b - a) * u + (c - a) * v + (a - b - c + d) * u * v) * 2 - 1
+    }
+    return { objects: [], refs: { canvas, g: canvas.getContext('2d'), tex, lib: { interpolate, rand, noise2 } } }` : `
+    return { objects: [], refs: {} }`;
+  const painterFrame = p.painter ? `
+    // Paint the procedural layer from ctx.time and ctx.data, then upload it.
+    const { canvas, g, tex } = content.refs
+    g.clearRect(0, 0, canvas.width, canvas.height)
+    // TODO: draw what no element can (grain, a blended HUD, noise blobs, masks)
+    tex.needsUpdate = true` : "";
+  return `// Scaffolded by \`vos port scaffold\` from ${p.source}.
+// Every word and colour is in \`data\`, bound to an element or read by a
+// painter; the knobs sit over them. What is left is the MOTION: translate each
+// scene where it says TODO, with the vos-port skill's tables open. Then:
+//   npx vos build program.mjs && npx vos check config.json
+//   npx vos compare . --against <the source's render>
+export default {
+  version: 2,
+  duration: ${p.duration},
+  camera: { preset: 'fullscreen' },
+  fonts: ${j(p.fonts)},
+  data: ${j(p.data)},
+  params: ${j(p.params)},
+  presets: ${j(p.presets)},
+  elements: ${j(p.elements)},
+
+  createContent(ctx) {
+    ctx.scene.background = new ctx.THREE.Color(ctx.data.bg)${painterContent}
+  },
+
+  createTimeline(ctx, content, duration) {
+    const tl = ctx.gsap.timeline()
+    for (const s of ctx.data.scenes) {
+      tl.addLabel(s.name, s.at)
+      // Each scene's words show in its window; the motion replaces this.
+      for (const id of ctx.data.sceneElements[s.name] || []) {
+        const p = ctx.elements.get(id).props
+        if (s.at > 0) {
+          tl.set(p, { opacity: 0 }, 0)
+          tl.set(p, { opacity: 1 }, s.at)
+        }
+        if (s.until != null && s.until < duration) tl.set(p, { opacity: 0 }, s.until)
+      }
+    }
+${sceneTodos}
+    tl.to({}, { duration }, 0)
+    return tl
+  },
+
+  onFrame(ctx, content) {
+    ctx.scene.background.set(ctx.data.bg)${painterFrame}
+  },
+}
+`;
+}
+function reportText(inv, r) {
+  const lines = [
+    `# Port report: ${inv.source}`,
+    "",
+    `${inv.engine} piece, ${inv.width}\xD7${inv.height}${inv.fps ? ` at ${inv.fps} fps` : ""}, ${inv.duration ?? "?"} s. A program has no size of its own: render it with \`--width ${inv.width} --height ${inv.height}\`.`,
+    "",
+    "## Placed",
+    "",
+    `- ${r.elements} words as bound text elements, ${Object.keys(inv.palette).length} palette colours from the source's custom properties, ${r.params} knobs.`,
+    `- ${inv.scenes.length} scenes as labels${inv.scenes.length ? "" : " (none declared: name them as you translate)"}.`,
+    ...inv.media.some((m) => m.kind === "audio") ? ["- the score as a doc.json track (vos push uploads it)."] : [],
+    "",
+    "## Faces",
+    "",
+    ...r.faces.map(
+      (f) => f.from ? `- **${f.from}** is not in the catalog: substituted with ${f.family}. Say so in the push note.` : `- ${f.family}${f.italic ? " (italic)" : ""}: from the catalog.`
+    ),
+    "",
+    "## Needs a painter or an approximation",
+    "",
+    ...inv.canvases.length ? [
+      `- ${inv.canvases.length} canvas${inv.canvases.length === 1 ? "" : "es"}: the source paints pixels; port those parts as the painter, with their values in data.`
+    ] : [],
+    ...inv.gaps.map((g) => `- ${g}`),
+    ...r.painter ? [] : ["- nothing: every visible part is an element."],
+    ...inv.scriptStrings.length && inv.canvases.length ? [
+      "",
+      "## Words the scripts paint",
+      "",
+      "The page draws these on its canvas, so no text node holds them. Each one a person reads becomes a data key and a bound element:",
+      "",
+      ...inv.scriptStrings.slice(0, 40).map((s) => `- ${JSON.stringify(s)}`)
+    ] : [],
+    ...inv.media.some((m) => m.kind === "image" || m.kind === "video") ? [
+      "",
+      "## Images and video",
+      "",
+      "Not placed: upload each with `vos asset upload` and add an image or video element over its hosted URL.",
+      "",
+      ...inv.media.filter((m) => m.kind === "image" || m.kind === "video").map((m) => `- ${m.kind} ${m.src ?? "(inline)"}`)
+    ] : [],
+    ...r.extra.length ? ["", "## Also", "", ...r.extra] : [],
+    "",
+    "## Reference",
+    "",
+    inv.render ? `The source's render: ${inv.render}. Stills in port/ref/. Check every scene: \`npx vos compare . --against ${inv.render}\`.` : "No render of the source was found: render it with its own tool and pass it to `vos compare --against`.",
+    ""
+  ];
+  return lines.join("\n");
+}
+function writeScaffold(plan, outDir) {
+  mkdirSync4(outDir, { recursive: true });
+  writeFileSync4(join22(outDir, "program.mjs"), plan.program);
+  writeFileSync4(
+    join22(outDir, "doc.json"),
+    JSON.stringify(plan.doc, null, 2) + "\n"
+  );
+  writeFileSync4(join22(dirname7(outDir), "REPORT.md"), plan.report);
+  for (const [from, name] of plan.copies) copyFileSync(from, join22(outDir, name));
+}
+function probeAudioDuration(file) {
+  const res = spawnSync3(
+    "ffprobe",
+    ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", file],
+    { encoding: "utf8" }
+  );
+  const d = Number((res.stdout ?? "").trim());
+  return Number.isFinite(d) && d > 0 ? Math.round(d * 1e3) / 1e3 : null;
+}
+
+// src/plugin/port.ts
+var BOOLEAN_FLAGS7 = /* @__PURE__ */ new Set(["json", "help"]);
+async function cmdPort(argv) {
+  const [sub, ...rest] = argv;
+  if (sub === "inventory") return await inventory(rest);
+  if (sub === "scaffold") return await scaffold(rest);
+  throw new UsageError(
+    "vos port inventory <page.html|project dir> [--render <their render.mp4>] [--out port] [--json]\nvos port scaffold [--from port/inventory.json] [--out port/program] [--json]"
+  );
+}
+async function inventory(argv) {
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS7);
+  const source = positionals[0] ?? ".";
+  const r = createReporter(flags.json === true);
+  const outDir = resolve11(strFlag(flags, "out") ?? "port");
+  mkdirSync5(outDir, { recursive: true });
+  const renderFlag = strFlag(flags, "render");
+  const inv = await readInventory(source, {
+    render: renderFlag === void 0 ? void 0 : resolve11(renderFlag),
+    outDir,
+    log: (l) => r.log(`note: ${l}`)
+  });
+  const file = join23(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(
+    `${inv.engine}, ${inv.width}\xD7${inv.height}${inv.fps ? `@${inv.fps}` : ""}, ${inv.duration ?? "?"}s: ${inv.texts.length} words, ${Object.keys(inv.palette).length} palette colours, ${inv.fonts.length} faces${missing.length ? ` (not in the catalog: ${missing.join(", ")})` : ""}, ${inv.media.length} media, ${inv.scenes.length} scenes, ${inv.canvases.length} canvases${inv.gaps.length ? `; needs a painter or an approximation: ${inv.gaps.join(", ")}` : ""}`
+  );
+  r.done(
+    { inventory: file, ...summary(inv) },
+    `Wrote ${file}${inv.stills.length ? ` and ${inv.stills.length} reference stills` : ""}. Next: npx vos port scaffold`
+  );
+  return EXIT_OK;
+}
+function summary(inv) {
+  return {
+    engine: inv.engine,
+    width: inv.width,
+    height: inv.height,
+    fps: inv.fps,
+    duration: inv.duration,
+    words: inv.texts.length,
+    palette: Object.keys(inv.palette).length,
+    faces: inv.fonts.map((f) => ({ family: f.family, catalog: f.catalog })),
+    media: inv.media.length,
+    scenes: inv.scenes.length,
+    canvases: inv.canvases.length,
+    gaps: inv.gaps,
+    render: inv.render
+  };
+}
+async function scaffold(argv) {
+  const { flags } = parseArgs(argv, BOOLEAN_FLAGS7);
+  const r = createReporter(flags.json === true);
+  const from = resolve11(strFlag(flags, "from") ?? join23("port", "inventory.json"));
+  if (!existsSync19(from))
+    throw new UsageError(
+      `no inventory at ${from}: run npx vos port inventory <source> first`
+    );
+  const inv = JSON.parse(readFileSync6(from, "utf8"));
+  const outDir = resolve11(
+    strFlag(flags, "out") ?? join23(dirname8(from), "program")
+  );
+  const plan = planScaffold(inv, {
+    sourceDir: dirname8(
+      resolve11(
+        inv.source.endsWith(".html") ? inv.source : join23(inv.source, "index.html")
+      )
+    ),
+    probeDuration: probeAudioDuration
+  });
+  writeScaffold(plan, outDir);
+  const programFile = join23(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(
+    join23(outDir, "config.json"),
+    JSON.stringify(built.config, null, 2) + "\n"
+  );
+  r.done(
+    { program: outDir, report: join23(dirname8(outDir), "REPORT.md") },
+    `Wrote ${outDir}/program.mjs, config.json and doc.json, and ${join23(dirname8(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;
+}
+
+// src/plugin/recipe.ts
+import { readFileSync as readFileSync7 } from "fs";
+import { basename as basename9 } from "path";
+var BOOLEAN_FLAGS8 = /* @__PURE__ */ new Set(["json", "help"]);
 var USAGE = "vos recipe push <file.md> (--folder <folderId|slug> | --asset <assetId>)";
 function recipeFilename(file) {
-  const name = basename6(file);
+  const name = basename9(file);
   if (!/\.md$/i.test(name)) {
     throw new UsageError(`a recipe is a markdown file \u2014 ${name} is not .md`);
   }
   return name;
 }
 async function cmdPush2(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS5);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8);
   const [file] = positionals;
   const folderRef = strFlag(flags, "folder");
   const assetId = strFlag(flags, "asset");
@@ -8834,7 +10173,7 @@ async function cmdPush2(argv) {
     throw new UsageError(USAGE);
   }
   const filename = recipeFilename(file);
-  const body = readFileSync4(file);
+  const body = readFileSync7(file);
   const r = createReporter(flags.json === true);
   const origin = platformOrigin({
     origin: strFlag(flags, "origin"),
@@ -8907,7 +10246,7 @@ async function cmdRecipe(argv) {
 
 // src/plugin/brand.ts
 import { writeFile as writeFile12 } from "fs/promises";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve12 } from "path";
 import { parseFrontmatter as parseFrontmatter2 } from "@vosjs/shared/frontmatter";
 import { lookKindForGround } from "@vosjs/studio-core";
 var HEX_RE = /#(?:[0-9a-f]{6}|[0-9a-f]{3})\b/gi;
@@ -9226,7 +10565,7 @@ async function cmdBrand(argv) {
     throw new UsageError(`not a URL: ${raw}`);
   }
   const r = createReporter(flags.json === true);
-  const out = resolve7(strFlag(flags, "out") ?? "BRAND.md");
+  const out = resolve12(strFlag(flags, "out") ?? "BRAND.md");
   r.log(`reading ${origin}/design.md and /llms.txt\u2026`);
   const [designText, llmsText] = await Promise.all([
     fetchText(`${origin}/design.md`),
@@ -9376,7 +10715,7 @@ async function recordHosted(input) {
 
 // src/plugin/agentBrowser.ts
 import { writeFile as writeFile13 } from "fs/promises";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve13 } from "path";
 function parseAgentBrowserLog(text) {
   const records = [];
   const problems = [];
@@ -9477,8 +10816,8 @@ var quoteAttr = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
 function hrefSelector(href) {
   try {
     const u = new URL(href);
-    const relative2 = `${u.pathname}${u.search}${u.hash}`;
-    return `a[href=${quoteAttr(relative2)}], a[href=${quoteAttr(href)}]`;
+    const relative3 = `${u.pathname}${u.search}${u.hash}`;
+    return `a[href=${quoteAttr(relative3)}], a[href=${quoteAttr(href)}]`;
   } catch {
     return `a[href=${quoteAttr(href)}]`;
   }
@@ -9847,7 +11186,7 @@ async function cmdActions(argv) {
     );
   }
   const r = createReporter(flags.json === true);
-  const out = resolve8(strFlag(flags, "out") ?? "actions.json");
+  const out = resolve13(strFlag(flags, "out") ?? "actions.json");
   const viewportFlag = strFlag(flags, "viewport");
   let viewport;
   if (viewportFlag) {
@@ -9856,7 +11195,7 @@ async function cmdActions(argv) {
     viewport = { width: Number(m[1]), height: Number(m[2]) };
   }
   const { readFile: readFile18 } = await import("fs/promises");
-  const text = await readFile18(resolve8(input), "utf8");
+  const text = await readFile18(resolve13(input), "utf8");
   const { records, problems } = parseAgentBrowserLog(text);
   for (const p of problems) r.log(`  ${p}`);
   const result = convertAgentBrowser(records, {
@@ -9866,7 +11205,7 @@ async function cmdActions(argv) {
   const errors = validateActions(result.actions);
   if (errors.length) {
     r.done(
-      { ok: false, errors, ...summary(result) },
+      { ok: false, errors, ...summary2(result) },
       `${input}: no actions file written
   ${errors.join("\n  ")}
   ${result.notes.join("\n  ")}`
@@ -9876,14 +11215,14 @@ async function cmdActions(argv) {
   await writeFile13(out, `${JSON.stringify(result.actions, null, 2)}
 `);
   r.done(
-    { ok: true, out, url: result.actions.url ?? null, ...summary(result) },
+    { ok: true, out, url: result.actions.url ?? null, ...summary2(result) },
     `Wrote ${out}: ${result.steps} step${result.steps === 1 ? "" : "s"} from ${records.length} record${records.length === 1 ? "" : "s"} (${result.ignored} read/session, ${result.skipped} skipped)` + (result.notes.length ? `
   ${result.notes.join("\n  ")}` : "") + `
 Then: vos record --actions ${out} --out take --strict`
   );
   return EXIT_OK;
 }
-function summary(result) {
+function summary2(result) {
   return {
     steps: result.steps,
     ignored: result.ignored,
@@ -9895,7 +11234,7 @@ async function cmdActionsScript(input, flags) {
   const r = createReporter(flags.json === true);
   const { readFile: readFile18 } = await import("fs/promises");
   const { shotList, formatShotList } = await import("./shotList-KH6FTX4L.js");
-  const raw = JSON.parse(await readFile18(resolve8(input), "utf8"));
+  const raw = JSON.parse(await readFile18(resolve13(input), "utf8"));
   const errors = validateActions(raw);
   if (errors.length) throw new UsageError(`${input}:
   ${errors.join("\n  ")}`);
@@ -9905,9 +11244,9 @@ async function cmdActionsScript(input, flags) {
 }
 
 // src/plugin/ingest.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { copyFile, mkdir as mkdir10, readFile as readFile16, stat as stat4 } from "fs/promises";
-import { basename as basename7, join as join19, resolve as resolve9 } from "path";
+import { basename as basename10, join as join24, resolve as resolve14 } from "path";
 import { inflateRawSync } from "zlib";
 import {
   cursorFromPlaywrightTrace,
@@ -9927,7 +11266,7 @@ import {
   Output,
   WebMOutputFormat
 } from "mediabunny";
-var BOOLEAN_FLAGS6 = /* @__PURE__ */ new Set(["json", "help"]);
+var BOOLEAN_FLAGS9 = /* @__PURE__ */ new Set(["json", "help"]);
 async function probeVideoFile(path) {
   const input = new Input({
     source: new FilePathSource(path),
@@ -9988,7 +11327,7 @@ async function copyRecording(src, dest, ext) {
   }
 }
 async function readTraceFile(path, offsetMs) {
-  const kind = traceKindOf(basename7(path));
+  const kind = traceKindOf(basename10(path));
   if (!kind) {
     throw new UsageError(
       `${path}: not a trace the recorder reads (trace.zip, .trace, .jsonl, .json or .csv)`
@@ -10009,7 +11348,7 @@ async function readTraceFile(path, offsetMs) {
     return cursorFromPlaywrightTrace(text2, { offsetMs });
   }
   const text = await readFile16(path, "utf8");
-  return cursorFromTrace(basename7(path), text, { offsetMs });
+  return cursorFromTrace(basename10(path), text, { offsetMs });
 }
 function parseViewport(v) {
   if (!v) return null;
@@ -10018,16 +11357,16 @@ function parseViewport(v) {
   return { width: Number(m[1]), height: Number(m[2]) };
 }
 async function cmdIngest(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS6, MULTI_FLAGS2);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS9, MULTI_FLAGS2);
   const source = positionals[0];
   if (!source)
     throw new UsageError(
       "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 = resolve9(source);
-  if (!existsSync17(videoPath)) throw new UsageError(`${source}: no such file`);
+  const videoPath = resolve14(source);
+  if (!existsSync20(videoPath)) throw new UsageError(`${source}: no such file`);
   const r = createReporter(flags.json === true);
-  const outDir = resolve9(strFlag(flags, "out") ?? "take");
+  const outDir = resolve14(strFlag(flags, "out") ?? "take");
   const offsetMs = numFlag(flags, "offset", 0);
   const viewportFlag = parseViewport(strFlag(flags, "viewport"));
   const cursorPath = strFlag(flags, "cursor");
@@ -10040,7 +11379,7 @@ async function cmdIngest(argv) {
       "note: finished footage opens bare, so --background is not used (pass --as take for the screen-recording card and its ground)"
     );
   const backdrop = footage ? null : await takeBackdrop(flags, r);
-  r.log(`probing ${basename7(videoPath)}\u2026`);
+  r.log(`probing ${basename10(videoPath)}\u2026`);
   const probed = await probeVideoFile(videoPath);
   if (!(probed.durationMs > 0)) {
     throw new UsageError(
@@ -10049,10 +11388,10 @@ async function cmdIngest(argv) {
   }
   let trace = null;
   if (cursorPath) {
-    trace = await readTraceFile(resolve9(cursorPath), offsetMs);
+    trace = await readTraceFile(resolve14(cursorPath), offsetMs);
     for (const n of trace.notes) r.log(`note: ${n}`);
   }
-  if (existsSync17(join19(outDir, "meta.json"))) {
+  if (existsSync20(join24(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` : "")
@@ -10060,7 +11399,7 @@ async function cmdIngest(argv) {
   }
   await mkdir10(outDir, { recursive: true });
   const paths = await ensureTakeDir(outDir);
-  const recording = join19(outDir, `recording.${probed.ext}`);
+  const recording = join24(outDir, `recording.${probed.ext}`);
   r.log("copying the recording\u2026");
   const remuxed = await copyRecording(videoPath, recording, probed.ext);
   const viewport = viewportFlag ?? trace?.viewport ?? {
@@ -10089,13 +11428,13 @@ async function cmdIngest(argv) {
   const clicks = events.filter((e) => e.type === "down").length;
   const seconds = (probed.durationMs / 1e3).toFixed(1);
   const facts = `${seconds}s, ${probed.width}\xD7${probed.height} @ ${meta.fps} fps${probed.hasAudio ? ", audio" : ", no audio"}${remuxed ? "" : ", copied as is"}`;
-  const cursorLine = trace ? `${events.length} cursor events (${clicks} clicks) from ${basename7(cursorPath)}${trace.dropped ? `, ${trace.dropped} not placed` : ""}; ${plan.zoomAuto} zoom${plan.zoomAuto === 1 ? "" : "s"} planned` : "no cursor track, so nothing was planned";
+  const cursorLine = trace ? `${events.length} cursor events (${clicks} clicks) from ${basename10(cursorPath)}${trace.dropped ? `, ${trace.dropped} not placed` : ""}; ${plan.zoomAuto} zoom${plan.zoomAuto === 1 ? "" : "s"} planned` : "no cursor track, so nothing was planned";
   const opened = footage ? `opened as finished footage: no card, no browser bar, no drawn cursor, ${meta.fps > 30 ? 60 : 30} fps export (--as take for a screen recording's card)` : `opened as a screen recording: the card, its ground and the drawn cursor (--as footage to open it bare)`;
   const next = footage && !trace ? `Next: vos push ${outDir} --wait \u2014 it lands as it is; trim or add to it in the studio` : trace ? `Next: vos digest ${outDir} \u2014 look before you cut; edit doc.json; vos push ${outDir}` : `Add --cursor <trace> recorded beside the video (a Playwright trace.zip, stamped JSON records, or a t,x,y,type CSV) to plan zooms from its clicks; else place them by eye: vos frames ${outDir} --times 0,25%,50%,75%,100%, then edit doc.json`;
   r.done(
     {
       out: outDir,
-      recording: basename7(recording),
+      recording: basename10(recording),
       durationMs: probed.durationMs,
       width: probed.width,
       height: probed.height,
@@ -10104,7 +11443,7 @@ async function cmdIngest(argv) {
       hasAudio: probed.hasAudio,
       remuxed,
       cursor: trace ? {
-        file: basename7(cursorPath),
+        file: basename10(cursorPath),
         kind: trace.kind,
         events: events.length,
         clicks,
@@ -10116,7 +11455,7 @@ async function cmdIngest(argv) {
       backdrop: plan.backdrop ?? null,
       as: footage ? "footage" : "take"
     },
-    `Ingested ${basename7(videoPath)} \u2192 ${outDir}/${basename7(recording)} (${facts})
+    `Ingested ${basename10(videoPath)} \u2192 ${outDir}/${basename10(recording)} (${facts})
   ${opened}
   ${cursorLine}
   ${next}`
@@ -10125,22 +11464,22 @@ async function cmdIngest(argv) {
 }
 
 // src/plugin/machineCmd.ts
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import {
   cpSync,
-  existsSync as existsSync19,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync6,
+  existsSync as existsSync22,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync9,
   rmSync as rmSync3,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync6
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join21 } from "path";
+import { join as join26 } from "path";
 import { chromium as chromium2 } from "playwright";
 
 // src/plugin/machine.ts
-import { existsSync as existsSync18, readFileSync as readFileSync5, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
-import { dirname as dirname5, join as join20 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync8, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
+import { dirname as dirname9, join as join25 } from "path";
 var AGENT_NAMES = [
   "claude",
   "cursor",
@@ -10160,17 +11499,17 @@ var HOME_DIRS = {
   copilot: [".copilot"]
 };
 function detectAgents(root, opts = {}) {
-  const exists = opts.exists ?? existsSync18;
+  const exists = opts.exists ?? existsSync21;
   const out = [];
   for (const agent of AGENT_NAMES) {
     for (const rel of PROJECT_DIRS[agent]) {
-      const dir = join20(root, rel);
+      const dir = join25(root, rel);
       if (exists(dir)) out.push({ agent, dir, scope: "project" });
     }
-    if (agent === "copilot" && !out.some((h) => h.agent === "copilot") && exists(join20(root, ".github", "copilot-instructions.md"))) {
+    if (agent === "copilot" && !out.some((h) => h.agent === "copilot") && exists(join25(root, ".github", "copilot-instructions.md"))) {
       out.push({
         agent,
-        dir: join20(root, ".github", "copilot"),
+        dir: join25(root, ".github", "copilot"),
         scope: "project"
       });
     }
@@ -10178,7 +11517,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 = join20(opts.home, rel);
+        const dir = join25(opts.home, rel);
         if (exists(dir)) out.push({ agent, dir, scope: "global" });
       }
     }
@@ -10196,26 +11535,26 @@ function agentsFromFlag(value, root) {
   return {
     homes: wanted.map((agent) => ({
       agent,
-      dir: join20(root, PROJECT_DIRS[agent][0]),
+      dir: join25(root, PROJECT_DIRS[agent][0]),
       scope: "project"
     }))
   };
 }
 function skillsDirFor(home) {
-  return join20(home.dir, "skills");
+  return join25(home.dir, "skills");
 }
 function fallbackSkillsHome(root) {
-  return { agent: "codex", dir: join20(root, ".agents"), scope: "project" };
+  return { agent: "codex", dir: join25(root, ".agents"), scope: "project" };
 }
-function installedSkills(dir, exists = existsSync18, list = (p) => {
+function installedSkills(dir, exists = existsSync21, list = (p) => {
   try {
-    return readdirSync4(p);
+    return readdirSync5(p);
   } catch {
     return [];
   }
 }) {
   if (!exists(dir)) return [];
-  return list(dir).filter((name) => exists(join20(dir, name, "SKILL.md"))).sort();
+  return list(dir).filter((name) => exists(join25(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 -->";
@@ -10247,10 +11586,10 @@ ${RULES_BLOCK}
   }
   return { text, changed: text !== current };
 }
-function rulesFileFor(root, exists = existsSync18) {
-  const agents = join20(root, "AGENTS.md");
+function rulesFileFor(root, exists = existsSync21) {
+  const agents = join25(root, "AGENTS.md");
   if (exists(agents)) return agents;
-  const claude = join20(root, "CLAUDE.md");
+  const claude = join25(root, "CLAUDE.md");
   if (exists(claude)) return claude;
   return agents;
 }
@@ -10259,14 +11598,14 @@ function chromeCandidates(platform, env) {
     return ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"];
   if (platform === "win32")
     return [
-      join20(
+      join25(
         env["PROGRAMFILES"] ?? "C:\\Program Files",
         "Google",
         "Chrome",
         "Application",
         "chrome.exe"
       ),
-      join20(
+      join25(
         env["LOCALAPPDATA"] ?? "",
         "Google",
         "Chrome",
@@ -10351,20 +11690,20 @@ function doctorReport(facts) {
   return { ok: nodeOk && browserOk, lines, next_step, facts };
 }
 function bundledSkillsDir(from) {
-  let dir = dirname5(from);
+  let dir = dirname9(from);
   for (let i = 0; i < 6; i++) {
-    const pkg = join20(dir, "package.json");
-    if (existsSync18(pkg)) {
+    const pkg = join25(dir, "package.json");
+    if (existsSync21(pkg)) {
       try {
-        const name = JSON.parse(readFileSync5(pkg, "utf8")).name;
+        const name = JSON.parse(readFileSync8(pkg, "utf8")).name;
         if (name === "@vosjs/cli") {
-          const skills = join20(dir, "skills");
-          return existsSync18(skills) && statSync5(skills).isDirectory() ? skills : null;
+          const skills = join25(dir, "skills");
+          return existsSync21(skills) && statSync6(skills).isDirectory() ? skills : null;
         }
       } catch {
       }
     }
-    const up = dirname5(dir);
+    const up = dirname9(dir);
     if (up === dir) break;
     dir = up;
   }
@@ -10372,7 +11711,7 @@ function bundledSkillsDir(from) {
 }
 
 // src/plugin/machineCmd.ts
-var BOOLEAN_FLAGS7 = /* @__PURE__ */ new Set([
+var BOOLEAN_FLAGS10 = /* @__PURE__ */ new Set([
   "json",
   "help",
   "global",
@@ -10390,21 +11729,21 @@ function npx() {
 function bundledChromium() {
   try {
     const p = chromium2.executablePath();
-    return p && existsSync19(p) ? p : null;
+    return p && existsSync22(p) ? p : null;
   } catch {
     return null;
   }
 }
-function probe() {
+function probe2() {
   return probeBrowser({
     platform: process.platform,
     env: process.env,
-    exists: existsSync19,
+    exists: existsSync22,
     bundled: bundledChromium
   });
 }
 function ffmpegVersion() {
-  const res = spawnSync("ffmpeg", ["-version"], { encoding: "utf8" });
+  const res = spawnSync4("ffmpeg", ["-version"], { encoding: "utf8" });
   if (res.status !== 0 || !res.stdout) return null;
   const m = /ffmpeg version (\S+)/.exec(res.stdout);
   return m ? m[1] : "present";
@@ -10442,7 +11781,7 @@ function skillsFacts(homes) {
 async function doctorFacts(opts) {
   return {
     node: process.versions.node,
-    browser: probe(),
+    browser: probe2(),
     ffmpeg: ffmpegVersion(),
     skills: skillsFacts(opts.homes),
     credential: resolveCredential() !== null,
@@ -10450,7 +11789,7 @@ async function doctorFacts(opts) {
   };
 }
 async function cmdSetup(argv) {
-  const { flags } = parseArgs(argv, BOOLEAN_FLAGS7);
+  const { flags } = parseArgs(argv, BOOLEAN_FLAGS10);
   const r = reporterFor(flags);
   const root = process.cwd();
   const global = flags.global === true;
@@ -10483,7 +11822,7 @@ async function cmdSetup(argv) {
       ...global ? ["-g"] : []
     ];
     r.log(`installing the vos skills: npx ${args.join(" ")}`);
-    const res = spawnSync(npx(), args, {
+    const res = spawnSync4(npx(), args, {
       cwd: root,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -10501,9 +11840,9 @@ async function cmdSetup(argv) {
       const targets = homes.length ? homes : [fallbackSkillsHome(root)];
       for (const home of targets) {
         const dest = skillsDirFor(home);
-        mkdirSync2(dest, { recursive: true });
+        mkdirSync6(dest, { recursive: true });
         for (const name of installedSkills(bundled)) {
-          cpSync(join21(bundled, name), join21(dest, name), { recursive: true });
+          cpSync(join26(bundled, name), join26(dest, name), { recursive: true });
         }
       }
       skillsVia = "bundled";
@@ -10520,27 +11859,27 @@ async function cmdSetup(argv) {
     ].sort();
   }
   r.event({ event: "skills", via: skillsVia, names: skillNames });
-  let browser = probe();
+  let browser = probe2();
   if (browser.kind === "none" && !noBrowser) {
     r.log(
       "no browser found; installing Chromium: npx playwright install chromium"
     );
-    spawnSync(npx(), ["playwright", "install", "chromium"], {
+    spawnSync4(npx(), ["playwright", "install", "chromium"], {
       cwd: root,
       stdio: ["ignore", "ignore", "inherit"],
       shell: process.platform === "win32",
       timeout: 6e5
     });
-    browser = probe();
+    browser = probe2();
   }
   r.event({ event: "browser", kind: browser.kind, path: browser.path });
   r.log(`browser: ${browser.line}`);
   let rules = null;
   if (!noRules) {
     const file = rulesFileFor(root);
-    const existing = existsSync19(file) ? readFileSync6(file, "utf8") : null;
+    const existing = existsSync22(file) ? readFileSync9(file, "utf8") : null;
     const { text, changed } = applyRulesBlock(existing);
-    if (changed) writeFileSync2(file, text);
+    if (changed) writeFileSync6(file, text);
     rules = { file, changed };
     r.log(
       changed ? `rules: wrote the vosso block into ${file}` : `rules: ${file} already carries the block`
@@ -10569,7 +11908,7 @@ Next: ${report.next_step}`
   return report.ok ? EXIT_OK : EXIT_NO_BROWSER;
 }
 async function cmdDoctor(argv) {
-  const { flags } = parseArgs(argv, BOOLEAN_FLAGS7);
+  const { flags } = parseArgs(argv, BOOLEAN_FLAGS10);
   const r = reporterFor(flags);
   const root = process.cwd();
   const homes = detectAgents(root, { home: homedir2(), global: true });
@@ -10588,7 +11927,7 @@ Next: ${report.next_step}`
   return report.ok ? EXIT_OK : EXIT_NO_BROWSER;
 }
 async function cmdWhoami(argv) {
-  const { flags } = parseArgs(argv, BOOLEAN_FLAGS7);
+  const { flags } = parseArgs(argv, BOOLEAN_FLAGS10);
   const r = reporterFor(flags);
   const origin = platformOrigin({
     origin: strFlag(flags, "origin"),
@@ -10650,9 +11989,9 @@ async function cmdWhoami(argv) {
   return EXIT_OK;
 }
 function cmdLogout(argv) {
-  const { flags } = parseArgs(argv, BOOLEAN_FLAGS7);
+  const { flags } = parseArgs(argv, BOOLEAN_FLAGS10);
   const r = reporterFor(flags);
-  const had = existsSync19(CREDENTIALS_PATH);
+  const had = existsSync22(CREDENTIALS_PATH);
   rmSync3(CREDENTIALS_PATH, { force: true });
   const envKey = Boolean(process.env.VOS_API_KEY?.trim());
   r.done(
@@ -10668,7 +12007,7 @@ function cmdLogout(argv) {
 }
 
 // src/plugin/run.ts
-var BOOLEAN_FLAGS8 = /* @__PURE__ */ new Set([
+var BOOLEAN_FLAGS11 = /* @__PURE__ */ new Set([
   "json",
   "help",
   "wait",
@@ -10714,6 +12053,14 @@ Take pipeline
   vos actions from-agent-browser <steps.jsonl> [--out actions.json] [--url <url>] [--viewport WxH] [--json]
   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]
             a take from a recording someone else made (a cloud agent's PR video, a Playwright run's video, a Loom export): the file becomes recording.<container>, meta.json from its own dimensions and duration, and a trace beside it becomes cursor.json so the planner has clicks to zoom on; without one, nothing is planned and the done event says so. Without a trace the file opens as FINISHED footage (a render from HyperFrames or Remotion, a film): no card, no browser bar, no drawn cursor, its own frame rate; --as take gives a screen demo the card
+  vos port inventory <page.html|project dir> [--render <their render.mp4>] [--out port] [--json]
+            a finished piece (HyperFrames, Remotion's render, a hand-rolled page) read as a browser renders it: words, palette, faces (catalog or missing), media, scenes, gaps \u2192 port/inventory.json, with stills from its render
+  vos port scaffold [--from port/inventory.json] [--out port/program] [--json]
+            a data-first program from it: every word a bound element, every colour a key, knobs, a label and a TODO per scene, the score as a doc.json track, port/REPORT.md
+  vos build <program.mjs> [--out config.json] [--json]
+            real functions \u2192 config.json, refusing a module-scope read, syntax the page cannot run and non-JSON data; config.sources.json maps each function to its line
+  vos compare <program dir|config.json> --against <their render.mp4> [--times a,b,50%] [--every 1] [--threshold 0.95] [--out compare] [--json]
+            per-frame SSIM and source | vos | difference sheets; exit 1 when ANY frame is under the threshold (needs ffmpeg)
   vos session open <url> --name <app>   a plain Chrome window on a vos-owned profile; sign in, close it
   vos session check <name> [--url <url>]   headless: does the session still open the page? exit 0/4
   vos session list | rm <name>          what exists and how old; delete one
@@ -11047,8 +12394,8 @@ function takeBrowserArgs(multi) {
 function takeStorageState(flags) {
   const raw = strFlag(flags, "storage-state");
   if (!raw) return void 0;
-  const path = resolve10(raw);
-  if (!existsSync20(path))
+  const path = resolve15(raw);
+  if (!existsSync23(path))
     throw new UsageError(`--storage-state: no such file: ${path}`);
   return path;
 }
@@ -11061,7 +12408,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 (!existsSync20(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)`
     );
@@ -11117,7 +12464,7 @@ function wallGate(flags, r, opts) {
 async function cmdRecord(argv) {
   const { positionals, flags, multi } = parseArgs(
     argv,
-    BOOLEAN_FLAGS8,
+    BOOLEAN_FLAGS11,
     MULTI_FLAGS2
   );
   const actionsPath = strFlag(flags, "actions") ?? positionals[0];
@@ -11130,7 +12477,7 @@ async function cmdRecord(argv) {
   const url = strFlag(flags, "url") ?? actions.url;
   if (!url)
     throw new UsageError('no URL \u2014 set "url" in the actions file or pass --url');
-  const outDir = resolve10(strFlag(flags, "out") ?? "take");
+  const outDir = resolve15(strFlag(flags, "out") ?? "take");
   const storageState = takeStorageState(flags);
   const sessionName = takeSessionName(flags, storageState);
   const browserArgs = takeBrowserArgs(multi);
@@ -11284,7 +12631,7 @@ ${lines.join("\n")}
   }
   const paths = takePaths(outDir);
   const prepare = async () => {
-    if (existsSync20(join22(outDir, "meta.json"))) {
+    if (existsSync23(join27(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" : "")
@@ -11349,7 +12696,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 ${join22(outDir, "doc.json")} (optional), then: vos render ${outDir}${exposureNote(rec)}`
+  Next: edit ${join27(outDir, "doc.json")} (optional), then: vos render ${outDir}${exposureNote(rec)}`
     );
     return strictFail ? EXIT_USAGE : EXIT_OK;
   } finally {
@@ -11359,7 +12706,7 @@ ${lines.join("\n")}
 async function cmdCreate2(argv) {
   const { positionals, flags, multi } = parseArgs(
     argv,
-    BOOLEAN_FLAGS8,
+    BOOLEAN_FLAGS11,
     MULTI_FLAGS2
   );
   const actionsPath = strFlag(flags, "actions");
@@ -11373,9 +12720,9 @@ async function cmdCreate2(argv) {
   const url = strFlag(flags, "url") ?? actions.url;
   if (!url)
     throw new UsageError('no URL \u2014 set "url" in the actions file or pass --url');
-  const outDir = resolve10(strFlag(flags, "out") ?? "take");
+  const outDir = resolve15(strFlag(flags, "out") ?? "take");
   const format = videoFormat(strFlag(flags, "format"), positionals[0]);
-  const out = positionals[0] ?? join22(outDir, `out.${format}`);
+  const out = positionals[0] ?? join27(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");
@@ -11388,7 +12735,7 @@ async function cmdCreate2(argv) {
   const headers = takeHeaders(multi);
   const paths = takePaths(outDir);
   const prepare = async () => {
-    if (existsSync20(join22(outDir, "meta.json"))) {
+    if (existsSync23(join27(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" : "")
@@ -11485,7 +12832,7 @@ async function cmdCreate2(argv) {
 async function cmdPlan(argv) {
   const { positionals, flags, multi } = parseArgs(
     argv,
-    BOOLEAN_FLAGS8,
+    BOOLEAN_FLAGS11,
     /* @__PURE__ */ new Set(["with"])
   );
   const dir = positionals[0];
@@ -11495,13 +12842,13 @@ async function cmdPlan(argv) {
     );
   const r = createReporter(flags.json === true);
   if (flags.fresh === true) {
-    await rm5(join22(dir, "doc.json"), { force: true });
+    await rm5(join27(dir, "doc.json"), { force: true });
     r.log("note: --fresh discarded the existing doc.json");
   }
   let reuse;
   if (flags.reuse === true) {
-    const from = resolve10(strFlag(flags, "from") ?? join22(dir, PREV_DOC_NAME));
-    if (!existsSync20(from)) {
+    const from = resolve15(strFlag(flags, "from") ?? join27(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>`
       );
@@ -11512,7 +12859,7 @@ async function cmdPlan(argv) {
     };
   }
   const style = await resolveStyleRef(flags);
-  const hasDoc = existsSync20(join22(dir, "doc.json"));
+  const hasDoc = existsSync23(join27(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;
@@ -11558,7 +12905,7 @@ async function cmdPlan(argv) {
     ${s.reuse.flagged.join("\n    ")}` : "") : "";
   r.done(
     {
-      take: resolve10(dir),
+      take: resolve15(dir),
       fresh: s.fresh,
       cursorKept: s.cursorKept,
       zoomAuto: s.zoomAuto,
@@ -11570,7 +12917,7 @@ async function cmdPlan(argv) {
       ...s.motion ? { motion: s.motion } : {},
       ...s.reuse ? { reuse: s.reuse } : {}
     },
-    `${s.reuse ? "Reused" : s.fresh ? "Planned" : "Refreshed"} ${join22(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"} ${join27(dir, "doc.json")}: ${s.zoomAuto} auto + ${s.zoomManual} manual zoom spans${s.cursorKept ? "" : " (cursor track dropped)"}${layoutLines}${motionLines}${reuseLines}`
   );
   return EXIT_OK;
 }
@@ -11683,7 +13030,7 @@ async function releaseInputs(dir, flags, r, withRefs = []) {
 async function cmdRender(argv) {
   const { positionals, flags, multi } = parseArgs(
     argv,
-    BOOLEAN_FLAGS8,
+    BOOLEAN_FLAGS11,
     MULTI_FLAGS2
   );
   const dir = positionals[0];
@@ -11693,7 +13040,7 @@ async function cmdRender(argv) {
     );
   const r = createReporter(flags.json === true);
   const format = videoFormat(strFlag(flags, "format"), positionals[1]);
-  const out = positionals[1] ?? join22(dir, `out.${format}`);
+  const out = positionals[1] ?? join27(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");
@@ -11751,7 +13098,7 @@ async function cmdRender(argv) {
 async function cmdFrames(argv) {
   const { positionals, flags, multi } = parseArgs(
     argv,
-    BOOLEAN_FLAGS8,
+    BOOLEAN_FLAGS11,
     MULTI_FLAGS2
   );
   const dir = positionals[0];
@@ -11777,7 +13124,7 @@ async function cmdFrames(argv) {
   const atStill = flags["at-still"] === true;
   let times;
   try {
-    times = frameRaw !== void 0 ? parseTimes(frameRaw, duration) : timesRaw !== void 0 ? parseTimes(timesRaw, duration) : atZooms || atMoments ? [] : parseTimes("0,25%,50%,75%,100%", duration);
+    times = frameRaw !== void 0 ? parseTimes2(frameRaw, duration) : timesRaw !== void 0 ? parseTimes2(timesRaw, duration) : atZooms || atMoments ? [] : parseTimes2("0,25%,50%,75%,100%", duration);
   } catch (e) {
     throw new UsageError(e instanceof Error ? e.message : String(e));
   }
@@ -11824,7 +13171,7 @@ async function cmdFrames(argv) {
 async function cmdDeliver(argv) {
   const { positionals, flags, multi } = parseArgs(
     argv,
-    BOOLEAN_FLAGS8,
+    BOOLEAN_FLAGS11,
     MULTI_FLAGS2
   );
   const dir = positionals[0];
@@ -11864,7 +13211,7 @@ async function cmdDeliver(argv) {
   if (timesRaw !== void 0) {
     try {
       const doc = take.doc;
-      times = timesRaw.split(",").map((s) => s.trim()).filter(Boolean).map((s) => resolveStepTime(doc, s) ?? parseTimes(s, duration)[0]);
+      times = timesRaw.split(",").map((s) => s.trim()).filter(Boolean).map((s) => resolveStepTime(doc, s) ?? parseTimes2(s, duration)[0]);
     } catch (e) {
       throw new UsageError(e instanceof Error ? e.message : String(e));
     }
@@ -11940,11 +13287,11 @@ async function resolveStyleRef(flags) {
 }
 async function resolveDocRef(ref, flags, what) {
   const styleRef = ref;
-  const file = existsSync20(styleRef) ? resolve10(
+  const file = existsSync23(styleRef) ? resolve15(
     styleRef,
-    existsSync20(join22(styleRef, "doc.json")) ? "doc.json" : ""
+    existsSync23(join27(styleRef, "doc.json")) ? "doc.json" : ""
   ) : null;
-  if (file && existsSync20(file)) {
+  if (file && existsSync23(file)) {
     return {
       from: file,
       doc: migrateHostedDoc5(
@@ -11990,7 +13337,7 @@ async function officialTemplate(origin, ref) {
   }
 }
 async function cmdDigest(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS11);
   const dir = positionals[0];
   if (!dir)
     throw new UsageError(
@@ -12031,7 +13378,7 @@ async function cmdDigest(argv) {
         kinds,
         frames: d.images.full,
         crops: d.images.crop,
-        sheet: d.images.sheet ? join22(result.outDir, d.images.sheet) : null,
+        sheet: d.images.sheet ? join27(result.outDir, d.images.sheet) : null,
         scenes: kinds.scene ?? 0,
         sourceDuration: d.take.sourceDuration,
         outputDuration: d.take.outputDuration,
@@ -12054,19 +13401,19 @@ async function cmdDigest(argv) {
   }
 }
 async function cmdOpen(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS11);
   const dir = positionals[0];
   if (!dir) throw new UsageError("vos open <take> [--studio <url>]");
   const r = createReporter(flags.json === true);
   const take = await loadTake(dir);
-  if (!existsSync20(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(
     /\/+$/,
     ""
   );
-  const server = await startTakeServer(resolve10(dir), {});
+  const server = await startTakeServer(resolve15(dir), {});
   const url = `${studio}/studio?take=${encodeURIComponent(server.base)}`;
   r.event({ event: "open", server: server.base, url });
   r.log(`take served at ${server.base}`);
@@ -12092,7 +13439,7 @@ async function cmdOpen(argv) {
   return EXIT_OK;
 }
 async function cmdJudge(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS11);
   const target = positionals[0];
   const against = strFlag(flags, "against");
   if (!target || !against)
@@ -12100,9 +13447,9 @@ async function cmdJudge(argv) {
       "vos judge <kit.json> --against <MANIFEST.json> [--out dir] [--json]\n(the manifest names the reference set: id, file, role, layout, facts, rule per asset)"
     );
   const r = createReporter(flags.json === true);
-  const kitFile = target.endsWith("kit.json") ? target : join22(target, "kit.json");
-  if (!existsSync20(kitFile)) throw new UsageError(`${kitFile}: no kit manifest`);
-  if (!existsSync20(against))
+  const kitFile = target.endsWith("kit.json") ? target : join27(target, "kit.json");
+  if (!existsSync23(kitFile)) throw new UsageError(`${kitFile}: no kit manifest`);
+  if (!existsSync23(against))
     throw new UsageError(`${against}: no reference manifest`);
   const result = await judgeKit(kitFile, against, strFlag(flags, "out"));
   const verdicts = JSON.parse(await readFile17(result.verdictFile, "utf8")).verdicts;
@@ -12121,7 +13468,7 @@ Win rate so far: ${rate.wins} win(s), ${rate.ties} tie(s) of ${rate.judged} judg
   return EXIT_OK;
 }
 async function cmdCallout(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS11);
   const dir = positionals[0];
   const shape = positionals[1];
   if (!dir || !shape || !isCalloutShape(shape))
@@ -12220,11 +13567,11 @@ async function cmdCallout(argv) {
   return EXIT_OK;
 }
 async function cmdValidate(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS11);
   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 : existsSync20(join22(target, "kit.json")) && !isTakeDir(target) ? join22(target, "kit.json") : null;
+  const kitTarget = target.endsWith("kit.json") ? target : existsSync23(join27(target, "kit.json")) && !isTakeDir(target) ? join27(target, "kit.json") : null;
   if (kitTarget) {
     const picture = flags.picture === true;
     const verdict = await validateKit(kitTarget, { picture });
@@ -12256,9 +13603,9 @@ async function cmdValidate(argv) {
     r.done({ valid: true, target }, `${target}: valid actions file`);
     return EXIT_OK;
   }
-  if (!isTakeDir(target) && existsSync20(join22(target, "config.json"))) {
+  if (!isTakeDir(target) && existsSync23(join27(target, "config.json"))) {
     const parsed = JSON.parse(
-      await readFile17(join22(target, "config.json"), "utf8")
+      await readFile17(join27(target, "config.json"), "utf8")
     );
     const pre = preflightConfig(parsed);
     const problems2 = pre.ok ? [] : pre.issues.map((i) => `config.json: ${i}`);
@@ -12274,9 +13621,9 @@ async function cmdValidate(argv) {
         ...collectConfigMediaUrls(pre.config ?? parsed),
         ...collectDocMediaUrls(doc)
       ];
-      const probe2 = mediaProbeLints(await probeMediaUrls([...new Set(urls)]));
-      problems2.push(...probe2.problems);
-      warnings2.push(...probe2.warnings);
+      const probe3 = mediaProbeLints(await probeMediaUrls([...new Set(urls)]));
+      problems2.push(...probe3.problems);
+      warnings2.push(...probe3.warnings);
     }
     if (problems2.length) {
       r.done(
@@ -12299,7 +13646,7 @@ async function cmdValidate(argv) {
   const take = await loadTake(target);
   const problems = [];
   const warnings = [];
-  if (!existsSync20(take.paths.recording)) {
+  if (!existsSync23(take.paths.recording)) {
     problems.push("missing recording (re-run record)");
   } else {
     const mismatch = containerMismatch(
@@ -12325,11 +13672,11 @@ async function cmdValidate(argv) {
     const lint = lintDoc(take.doc);
     problems.push(...lint.problems.map((p) => `doc.json: ${p}`));
     warnings.push(...lint.warnings.map((w) => `doc.json: ${w}`));
-    const probe2 = mediaProbeLints(
+    const probe3 = mediaProbeLints(
       await probeMediaUrls(collectDocMediaUrls(take.doc))
     );
-    problems.push(...probe2.problems);
-    warnings.push(...probe2.warnings);
+    problems.push(...probe3.problems);
+    warnings.push(...probe3.warnings);
     if (flags.picture === true && (take.doc.overlays ?? []).some((o) => o.kind === "html")) {
       const doc = take.doc;
       const times = [
@@ -12382,7 +13729,7 @@ async function cmdValidate(argv) {
 async function cmdPush3(argv) {
   const { positionals, flags, multi } = parseArgs(
     argv,
-    BOOLEAN_FLAGS8,
+    BOOLEAN_FLAGS11,
     MULTI_FLAGS2
   );
   const dir = positionals[0];
@@ -12392,7 +13739,7 @@ async function cmdPush3(argv) {
     );
   const refusal = takePushRefusal({
     vos: strFlag(flags, "vos"),
-    trackedVosId: readSyncState(resolve10(dir))?.vosId ?? null,
+    trackedVosId: readSyncState(resolve15(dir))?.vosId ?? null,
     programOnly: ["slug", "desc", "tags", "base", "remix-of", "still"].filter(
       (name) => hasFlag(flags, name)
     )
@@ -12401,7 +13748,7 @@ async function cmdPush3(argv) {
   const r = createReporter(flags.json === true);
   const overrides = multi.override;
   const result = await pushTake(
-    resolve10(dir),
+    resolve15(dir),
     {
       key: strFlag(flags, "key"),
       api: strFlag(flags, "api"),
@@ -12446,11 +13793,11 @@ ${landedLines(landed)}` : "")
   return EXIT_OK;
 }
 async function cmdPull2(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8, MULTI_FLAGS2);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS11, MULTI_FLAGS2);
   const dir = positionals[0] ?? ".";
   const r = createReporter(flags.json === true);
   const result = await pullTake(
-    resolve10(dir),
+    resolve15(dir),
     {
       key: strFlag(flags, "key"),
       api: strFlag(flags, "api"),
@@ -12559,6 +13906,12 @@ async function run(argv) {
       }
       case "delete":
         return await cmdDelete(rest);
+      case "build":
+        return await cmdBuild(rest);
+      case "compare":
+        return await cmdCompare(rest);
+      case "port":
+        return await cmdPort(rest);
       case "folder":
         return await cmdFolder(rest);
       case "asset":
@@ -12605,7 +13958,7 @@ async function run(argv) {
   }
 }
 async function cmdSession(argv) {
-  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS8);
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS11);
   const [sub, arg] = positionals;
   const r = createReporter(flags.json === true);
   const usage = "vos session open <url> --name <app> | check <name> [--url <url>] | list | rm <name>";
@@ -12624,38 +13977,38 @@ async function cmdSession(argv) {
       if (!/^https?:$/.test(url.protocol))
         throw new UsageError("vos session open wants an http(s) URL");
       await openSession(name, url.href, { log: r.log });
-      const summary2 = await summarizeSession(name);
+      const summary3 = await summarizeSession(name);
       r.done(
         {
-          name: summary2.name,
-          origins: summary2.origins,
-          newestExpires: summary2.newestExpires,
-          sessionOnly: summary2.sessionOnly
+          name: summary3.name,
+          origins: summary3.origins,
+          newestExpires: summary3.newestExpires,
+          sessionOnly: summary3.sessionOnly
         },
-        `${summaryLine(summary2)}
+        `${summaryLine(summary3)}
   Record on it: vos record --actions actions.json --out take --session ${name} --strict`
       );
-      return summary2.origins.length ? EXIT_OK : EXIT_ERROR;
+      return summary3.origins.length ? EXIT_OK : EXIT_ERROR;
     }
     case "check": {
       if (!arg) throw new UsageError(usage);
       const bad = sessionNameVerdict(arg);
       if (bad) throw new UsageError(bad);
-      if (!existsSync20(sessionDir(arg)))
+      if (!existsSync23(sessionDir(arg)))
         throw new UsageError(`no session "${arg}" (vos session list)`);
-      const summary2 = await summarizeSession(arg);
+      const summary3 = await summarizeSession(arg);
       const url = strFlag(flags, "url");
       if (!url) {
         r.done(
           {
             name: arg,
-            origins: summary2.origins,
-            newestExpires: summary2.newestExpires,
-            sessionOnly: summary2.sessionOnly
+            origins: summary3.origins,
+            newestExpires: summary3.newestExpires,
+            sessionOnly: summary3.sessionOnly
           },
-          summaryLine(summary2)
+          summaryLine(summary3)
         );
-        return summary2.origins.length ? EXIT_OK : EXIT_WALL;
+        return summary3.origins.length ? EXIT_OK : EXIT_WALL;
       }
       const verdict = await withSession(arg, async (ctx) => {
         const page = await ctx.newPage();
@@ -12676,8 +14029,8 @@ async function cmdSession(argv) {
             name: arg,
             ok: false,
             wall: verdict,
-            origins: summary2.origins,
-            newestExpires: summary2.newestExpires
+            origins: summary3.origins,
+            newestExpires: summary3.newestExpires
           },
           `session "${arg}" no longer opens ${url}: ${verdict.message.split(". ")[0]}. It expired, or the sign-in never landed. Sign in again: vos session open ${url} --name ${arg}`
         );
@@ -12687,10 +14040,10 @@ async function cmdSession(argv) {
         {
           name: arg,
           ok: true,
-          origins: summary2.origins,
-          newestExpires: summary2.newestExpires
+          origins: summary3.origins,
+          newestExpires: summary3.newestExpires
         },
-        `session "${arg}" opens ${url} signed in. ${summaryLine(summary2)}`
+        `session "${arg}" opens ${url} signed in. ${summaryLine(summary3)}`
       );
       return EXIT_OK;
     }
@@ -12745,4 +14098,4 @@ export {
   verbHelp,
   run
 };
-//# sourceMappingURL=chunk-MJYXP4AA.js.map
+//# sourceMappingURL=chunk-M22MAUMZ.js.map