@vosjs/cli 0.13.0 → 0.14.0

package/dist/{chunk-6TFKMNSG.js → chunk-MMKDYE57.js}

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
 import {
   BrowserUnavailableError,
+  directoryKind,
   launchBrowser
-} from "./chunk-A2VSDK3C.js";
+} from "./chunk-NHKHTIDR.js";
 
 // src/plugin/run.ts
-import { mkdir as mkdir7, readFile as readFile9, rm as rm4 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import { join as join14, resolve as resolve6 } from "path";
+import { mkdir as mkdir8, readFile as readFile12, rm as rm4 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import { join as join15, resolve as resolve7 } from "path";
 import { totalDuration as totalDuration2 } from "@vosjs/timeline";
-import { migrateHostedDoc as migrateHostedDoc4, ratedSegments as ratedSegments4 } from "@vosjs/studio-core";
+import { migrateHostedDoc as migrateHostedDoc4, ratedSegments as ratedSegments6 } from "@vosjs/studio-core";
 
 // src/plugin/args.ts
 var UsageError = class extends Error {
@@ -126,22 +127,22 @@ function validateActions(value) {
   }
   const seenIds = /* @__PURE__ */ new Set();
   obj.steps.forEach((raw, i) => {
-    const at = `steps[${i}]`;
+    const at2 = `steps[${i}]`;
     if (typeof raw !== "object" || raw === null) {
-      errors.push(`${at}: must be an object`);
+      errors.push(`${at2}: must be an object`);
       return;
     }
     const s = raw;
     if (typeof s.do !== "string" || !VERBS.has(s.do)) {
-      errors.push(`${at}: "do" must be one of ${[...VERBS].join(", ")}`);
+      errors.push(`${at2}: "do" must be one of ${[...VERBS].join(", ")}`);
       return;
     }
     if (s.id !== void 0) {
       if (typeof s.id !== "string" || !s.id.trim()) {
-        errors.push(`${at}: id must be a non-empty string`);
+        errors.push(`${at2}: id must be a non-empty string`);
       } else if (seenIds.has(s.id)) {
         errors.push(
-          `${at}: duplicate id "${s.id}" \u2014 an anchor could not tell the two steps apart`
+          `${at2}: duplicate id "${s.id}" \u2014 an anchor could not tell the two steps apart`
         );
       } else {
         seenIds.add(s.id);
@@ -149,26 +150,26 @@ function validateActions(value) {
     }
     const needSelector = s.do === "hover" || s.do === "click" || s.do === "type";
     if (needSelector && typeof s.selector !== "string")
-      errors.push(`${at}: ${s.do} needs a selector`);
+      errors.push(`${at2}: ${s.do} needs a selector`);
     if (s.do === "wait" && typeof s.ms !== "number")
-      errors.push(`${at}: wait needs ms`);
+      errors.push(`${at2}: wait needs ms`);
     if (s.do === "type" && typeof s.text !== "string")
-      errors.push(`${at}: type needs text`);
+      errors.push(`${at2}: type needs text`);
     if (s.do === "type" && s.focus !== void 0 && typeof s.focus !== "boolean")
-      errors.push(`${at}: type focus must be true or false`);
+      errors.push(`${at2}: type focus must be true or false`);
     if (s.do === "scroll" && typeof s.dy !== "number")
-      errors.push(`${at}: scroll needs dy`);
+      errors.push(`${at2}: scroll needs dy`);
     if (s.do === "move" && (typeof s.x !== "number" || typeof s.y !== "number")) {
-      errors.push(`${at}: move needs x and y (CSS px)`);
+      errors.push(`${at2}: move needs x and y (CSS px)`);
     }
     if (s.do === "drag") {
       if (typeof s.tx !== "number" || typeof s.ty !== "number") {
-        errors.push(`${at}: drag needs tx and ty (CSS px)`);
+        errors.push(`${at2}: drag needs tx and ty (CSS px)`);
       }
       const hasStart = typeof s.selector === "string" || typeof s.x === "number" && typeof s.y === "number";
       if (!hasStart)
         errors.push(
-          `${at}: drag needs a selector OR x and y as the start point`
+          `${at2}: drag needs a selector OR x and y as the start point`
         );
     }
   });
@@ -316,6 +317,33 @@ function lintDoc(docIn) {
         );
       }
     }
+    for (const [i, seg] of (Array.isArray(doc.segments) ? doc.segments : []).entries()) {
+      const hold = seg.hold;
+      if (hold !== void 0 && (!isNum(hold) || hold < 0 || hold > 10)) {
+        problems.push(
+          `segments[${i}].hold must be 0..10 output seconds (got ${String(hold)})`
+        );
+      }
+    }
+    const endCard = doc.endCard;
+    if (endCard !== void 0) {
+      if (typeof endCard !== "object" || endCard === null) {
+        problems.push("endCard must be an object: {seconds?, headline?, sub?, wordmark?}");
+      } else {
+        const ec = endCard;
+        if (ec.seconds !== void 0 && (!isNum(ec.seconds) || ec.seconds < 1 || ec.seconds > 8)) {
+          problems.push(`endCard.seconds must be 1..8 (got ${String(ec.seconds)}); absent = 2.5`);
+        }
+        for (const k of ["headline", "sub", "wordmark"]) {
+          if (ec[k] !== void 0 && typeof ec[k] !== "string") {
+            problems.push(`endCard.${k} must be a string`);
+          }
+        }
+        if (!["headline", "sub", "wordmark"].some((k) => typeof ec[k] === "string" && ec[k].trim())) {
+          warnings.push("endCard carries no words: it holds the last frame and recedes the card over nothing");
+        }
+      }
+    }
     if (doc.segments !== void 0 && !Array.isArray(doc.segments)) {
       problems.push("segments must be an array of {in, out} spans");
     }
@@ -523,9 +551,69 @@ function lintDoc(docIn) {
           "frame.borderWidth/borderColor are set but frame.border is 0 \u2014 border is the switch AND the alpha, so nothing is drawn"
         );
       }
+      const sc = frame.shadowContact;
+      if (sc !== void 0 && (!isNum(sc) || sc < 0 || sc > 1)) {
+        problems.push(
+          `frame.shadowContact must be 0..1 (got ${String(sc)}); absent = no contact layer`
+        );
+      }
+      const shc = frame.shadowColor;
+      if (shc !== void 0 && !/^#[0-9a-fA-F]{6}$/.test(String(shc))) {
+        problems.push(
+          `frame.shadowColor must be a #rrggbb hex (got ${String(shc)}); absent = black`
+        );
+      }
+      const ent = frame.entrance;
+      if (ent !== void 0) {
+        const kinds = ["tilt-in", "pull-out", "rise", "none"];
+        if (typeof ent !== "object" || ent === null || !kinds.includes(String(ent.kind))) {
+          problems.push(
+            `frame.entrance.kind must be one of ${kinds.join(" | ")} (got ${JSON.stringify(ent)})`
+          );
+        } else {
+          const secs = ent.seconds;
+          if (secs !== void 0 && (!isNum(secs) || secs < 0.2 || secs > 3)) {
+            problems.push(
+              `frame.entrance.seconds must be 0.2..3 (got ${String(secs)}); absent = 1.2`
+            );
+          }
+        }
+      }
+      if (frame.focusFollow !== void 0 && frame.focusFollow !== "camera") {
+        problems.push(
+          `frame.focusFollow must be "camera" (got ${String(frame.focusFollow)}); it reads under fit: cover only`
+        );
+      }
+      const ins = frame.inset;
+      if (ins !== void 0) {
+        if (typeof ins !== "object" || ins === null || Array.isArray(ins)) {
+          problems.push(
+            "frame.inset must be an object of {top, right, bottom, left} fractions"
+          );
+        } else {
+          const sides = ins;
+          for (const side of ["top", "right", "bottom", "left"]) {
+            const v = sides[side];
+            if (v !== void 0 && (!isNum(v) || v < -2 || v > 0.9)) {
+              problems.push(
+                `frame.inset.${side} must be a fraction of the frame in -2..0.9 (got ${String(v)}); negative bleeds the card past the edge`
+              );
+            }
+          }
+          const l = isNum(sides.left) ? sides.left : 0;
+          const r = isNum(sides.right) ? sides.right : 0;
+          const t = isNum(sides.top) ? sides.top : 0;
+          const b = isNum(sides.bottom) ? sides.bottom : 0;
+          if (l + r >= 1 || t + b >= 1) {
+            problems.push(
+              `frame.inset leaves no room for the card (left+right ${l + r}, top+bottom ${t + b}; each pair must stay under 1)`
+            );
+          }
+        }
+      }
       const ebw = isNum(bw) && bw > 0 && bw <= 24 ? bw : 1.5;
       const pad = isNum(frame.padding) ? frame.padding : 0;
-      if (frame.border && ebw > pad) {
+      if (frame.border && ebw > pad && ins === void 0) {
         warnings.push(
           `frame.borderWidth (${ebw}) is wider than frame.padding (${pad}) \u2014 the border grows outward from the card, so the frame edge crops it; raise the padding to at least the width to show the whole stroke`
         );
@@ -1259,10 +1347,10 @@ function startTakeServer(rootDir, pages) {
     res.writeHead(404).end();
   });
   return new Promise(
-    (resolve7) => server.listen(0, () => {
+    (resolve8) => server.listen(0, () => {
       const addr = server.address();
       const port = typeof addr === "object" && addr ? addr.port : 0;
-      resolve7({ base: `http://localhost:${port}`, close: () => server.close() });
+      resolve8({ base: `http://localhost:${port}`, close: () => server.close() });
     })
   );
 }
@@ -1276,10 +1364,10 @@ async function waitForPageDone(page, label, onProgress, timeoutMs) {
     if (state.error) throw new Error(`${label} failed: ${state.error}`);
     if (state.done) return state.done;
     if (typeof state.progress === "number") {
-      const pct = Math.floor(state.progress * 10) * 10;
-      if (pct !== last) {
+      const pct2 = Math.floor(state.progress * 10) * 10;
+      if (pct2 !== last) {
         onProgress(state.progress);
-        last = pct;
+        last = pct2;
       }
     }
     if (Date.now() - start > timeoutMs) {
@@ -1499,14 +1587,14 @@ async function renderInPage(opts) {
     w.__error = String(e instanceof Error && e.stack || e);
   }
 }
-async function renderChunk(context, serverBase, chunk, opts, onChunkProgress) {
-  const outName = `render-chunk-${chunk.index}.tmp`;
+async function renderChunk(context, serverBase, chunk2, opts, onChunkProgress) {
+  const outName = `render-chunk-${chunk2.index}.tmp`;
   const page = await context.newPage();
   try {
     page.on("console", (m) => {
       if (m.type() === "error" || process.env.VOS_RENDER_DEBUG)
         process.stderr.write(
-          `   [render page ${chunk.index} ${m.type()}] ${m.text()}
+          `   [render page ${chunk2.index} ${m.type()}] ${m.text()}
 `
         );
     });
@@ -1514,7 +1602,7 @@ async function renderChunk(context, serverBase, chunk, opts, onChunkProgress) {
       page.on(
         "pageerror",
         (e) => process.stderr.write(
-          `   [render pageerror ${chunk.index}] ${String(e)}
+          `   [render pageerror ${chunk2.index}] ${String(e)}
 `
         )
       );
@@ -1533,8 +1621,8 @@ async function renderChunk(context, serverBase, chunk, opts, onChunkProgress) {
       W: opts.width,
       H: opts.height,
       fps: opts.fps,
-      startFrame: chunk.startFrame + frameOffset,
-      endFrame: chunk.endFrame + frameOffset,
+      startFrame: chunk2.startFrame + frameOffset,
+      endFrame: chunk2.endFrame + frameOffset,
       format: opts.format,
       bitrate: opts.bitrate ?? 1e7,
       mediabunnyUrl: MEDIABUNNY_URL,
@@ -1545,10 +1633,10 @@ async function renderChunk(context, serverBase, chunk, opts, onChunkProgress) {
       audioDuration: audio?.duration
     }).catch(() => {
     });
-    const timeoutMs = 12e4 + chunk.frameCount * 500;
+    const timeoutMs = 12e4 + chunk2.frameCount * 500;
     await waitForPageDone(
       page,
-      `render chunk ${chunk.index}`,
+      `render chunk ${chunk2.index}`,
       onChunkProgress,
       timeoutMs
     );
@@ -1580,8 +1668,8 @@ async function renderAnimation(browser, opts) {
     };
     const outNames = await Promise.all(
       chunks.map(
-        (chunk) => renderChunk(context, server.base, chunk, effOpts, (fraction) => {
-          progress[chunk.index] = fraction;
+        (chunk2) => renderChunk(context, server.base, chunk2, effOpts, (fraction) => {
+          progress[chunk2.index] = fraction;
           reportProgress();
         })
       )
@@ -1596,9 +1684,9 @@ async function renderAnimation(browser, opts) {
       return { bytes: new Uint8Array(files[0]), totalFrames, chunks: 1 };
     }
     const { bytes } = await concatEncodedVideo(
-      chunks.map((chunk, i) => ({
+      chunks.map((chunk2, i) => ({
         data: new Uint8Array(files[i]),
-        duration: chunk.duration
+        duration: chunk2.duration
       })),
       { format: opts.format, frameRate: opts.fps }
     );
@@ -2505,7 +2593,6 @@ async function writeIndexJson(result) {
 
 // src/plugin/deliver.ts
 import {
-  copyFile,
   mkdir as mkdir4,
   mkdtemp,
   rename as rename4,
@@ -2516,12 +2603,18 @@ import {
 import { tmpdir } from "os";
 import { join as join5, relative, resolve as resolve3 } from "path";
 import { totalDuration } from "@vosjs/timeline";
+import { existsSync as existsSync5 } from "fs";
+import { readFile as readFile5 } from "fs/promises";
+import { parseFrontmatter } from "@vosjs/shared/frontmatter";
 import {
   CHANNEL_SPECS_VERIFIED,
   DESTINATIONS,
+  cardInset,
   destinationsForChannel,
-  ratedSegments as ratedSegments3,
-  spanOutputExtent as spanOutputExtent3
+  houseLook,
+  isLookKind,
+  lookFromBrand,
+  ratedSegments as ratedSegments5
 } from "@vosjs/studio-core";
 
 // src/plugin/renderTake.ts
@@ -2716,6 +2809,1336 @@ async function renderPosterStills(browser, config, serveDir, shots, time) {
   }
 }
 
+// src/plugin/moments.ts
+import { ratedSegments as ratedSegments3, spanOutputExtent as spanOutputExtent3 } from "@vosjs/studio-core";
+
+// src/plugin/picture.ts
+import { inflateSync } from "zlib";
+var PNG_SIG = [137, 80, 78, 71, 13, 10, 26, 10];
+function decodePng(bytes) {
+  if (bytes.length < 33) return null;
+  for (let i = 0; i < 8; i++) if (bytes[i] !== PNG_SIG[i]) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let pos = 8;
+  let w = 0;
+  let h = 0;
+  let depth = 0;
+  let colorType = 0;
+  let interlace = 0;
+  const idat = [];
+  while (pos + 8 <= bytes.length) {
+    const len = view.getUint32(pos);
+    const type = String.fromCharCode(
+      bytes[pos + 4],
+      bytes[pos + 5],
+      bytes[pos + 6],
+      bytes[pos + 7]
+    );
+    const start = pos + 8;
+    if (type === "IHDR") {
+      w = view.getUint32(start);
+      h = view.getUint32(start + 4);
+      depth = bytes[start + 8];
+      colorType = bytes[start + 9];
+      interlace = bytes[start + 12];
+    } else if (type === "IDAT") {
+      idat.push(bytes.subarray(start, start + len));
+    } else if (type === "IEND") break;
+    pos = start + len + 4;
+  }
+  if (!w || !h || depth !== 8 || interlace !== 0) return null;
+  const channels = colorType === 6 ? 4 : colorType === 2 ? 3 : colorType === 4 ? 2 : colorType === 0 ? 1 : 0;
+  if (!channels) return null;
+  const total = idat.reduce((n, c) => n + c.length, 0);
+  const joined = new Uint8Array(total);
+  let off2 = 0;
+  for (const c of idat) {
+    joined.set(c, off2);
+    off2 += c.length;
+  }
+  let raw;
+  try {
+    raw = new Uint8Array(inflateSync(joined));
+  } catch {
+    return null;
+  }
+  const stride = w * channels;
+  if (raw.length < (stride + 1) * h) return null;
+  const out = new Uint8Array(w * h * 4);
+  const prev = new Uint8Array(stride);
+  const cur = new Uint8Array(stride);
+  for (let y = 0; y < h; y++) {
+    const filter = raw[y * (stride + 1)];
+    const rowStart = y * (stride + 1) + 1;
+    for (let i = 0; i < stride; i++) {
+      const x = raw[rowStart + i];
+      const a = i >= channels ? cur[i - channels] : 0;
+      const b = prev[i];
+      const c = i >= channels ? prev[i - channels] : 0;
+      let v;
+      switch (filter) {
+        case 0:
+          v = x;
+          break;
+        case 1:
+          v = x + a;
+          break;
+        case 2:
+          v = x + b;
+          break;
+        case 3:
+          v = x + (a + b >> 1);
+          break;
+        case 4: {
+          const p = a + b - c;
+          const pa = Math.abs(p - a);
+          const pb = Math.abs(p - b);
+          const pc = Math.abs(p - c);
+          v = x + (pa <= pb && pa <= pc ? a : pb <= pc ? b : c);
+          break;
+        }
+        default:
+          return null;
+      }
+      cur[i] = v & 255;
+    }
+    for (let px = 0; px < w; px++) {
+      const o = (y * w + px) * 4;
+      const s = px * channels;
+      if (channels >= 3) {
+        out[o] = cur[s];
+        out[o + 1] = cur[s + 1];
+        out[o + 2] = cur[s + 2];
+        out[o + 3] = channels === 4 ? cur[s + 3] : 255;
+      } else {
+        out[o] = out[o + 1] = out[o + 2] = cur[s];
+        out[o + 3] = channels === 2 ? cur[s + 1] : 255;
+      }
+    }
+    prev.set(cur);
+  }
+  return { w, h, data: out };
+}
+var at = (img, x, y) => {
+  const o = (y * img.w + x) * 4;
+  return [img.data[o], img.data[o + 1], img.data[o + 2]];
+};
+var median = (a) => {
+  const s = [...a].sort((x, y) => x - y);
+  return s[s.length >> 1] ?? 0;
+};
+function groundColour(img) {
+  const ring = Math.max(1, Math.round(Math.min(img.w, img.h) * 0.01));
+  const r = [];
+  const g = [];
+  const b = [];
+  const step = Math.max(1, Math.round(Math.max(img.w, img.h) / 400));
+  for (let y = 0; y < img.h; y += step) {
+    for (let x = 0; x < img.w; x += step) {
+      if (x < ring || y < ring || x >= img.w - ring || y >= img.h - ring) {
+        const p = at(img, x, y);
+        r.push(p[0]);
+        g.push(p[1]);
+        b.push(p[2]);
+      }
+    }
+  }
+  return [median(r), median(g), median(b)];
+}
+var hex = (c) => "#" + c.map((v) => v.toString(16).padStart(2, "0")).join("");
+var delta = (p, q) => Math.abs(p[0] - q[0]) + Math.abs(p[1] - q[1]) + Math.abs(p[2] - q[2]);
+function cardBounds(img, ground, threshold = 60) {
+  let x0 = img.w;
+  let y0 = img.h;
+  let x1 = -1;
+  let y1 = -1;
+  const step = Math.max(1, Math.round(Math.max(img.w, img.h) / 700));
+  for (let y = 0; y < img.h; y += step) {
+    for (let x = 0; x < img.w; x += step) {
+      if (delta(at(img, x, y), ground) > threshold) {
+        if (x < x0) x0 = x;
+        if (y < y0) y0 = y;
+        if (x > x1) x1 = x;
+        if (y > y1) y1 = y;
+      }
+    }
+  }
+  if (x1 < 0) return null;
+  return { x: x0, y: y0, w: x1 - x0 + 1, h: y1 - y0 + 1 };
+}
+function haloReading(img, ground, card) {
+  const band = Math.max(2, Math.round(Math.min(img.w, img.h) * 0.012));
+  const meanRect = (x0, y0, x1, y1) => {
+    let sum = 0;
+    let n = 0;
+    const sx = Math.max(1, Math.round((x1 - x0) / 60));
+    const sy = Math.max(1, Math.round((y1 - y0) / 60));
+    for (let y = Math.max(0, y0); y < Math.min(img.h, y1); y += sy) {
+      for (let x = Math.max(0, x0); x < Math.min(img.w, x1); x += sx) {
+        sum += delta(at(img, x, y), ground);
+        n++;
+      }
+    }
+    return n ? sum / n : 0;
+  };
+  const rise = (bands) => {
+    const [outer, mid] = bands;
+    return outer >= 3 && mid - outer >= 1.5 ? mid : 0;
+  };
+  const readings = [];
+  const yA = card.y + card.h * 0.2;
+  const yB = card.y + card.h * 0.8;
+  if (card.x >= 1 && card.w > band * 4) {
+    const x0 = card.x;
+    readings.push(
+      rise([
+        meanRect(x0, yA, x0 + band, yB),
+        meanRect(x0 + band, yA, x0 + band * 2, yB),
+        meanRect(x0 + band * 2, yA, x0 + band * 3, yB)
+      ])
+    );
+  }
+  if (card.x + card.w <= img.w - 1 && card.w > band * 4) {
+    const x1 = card.x + card.w;
+    readings.push(
+      rise([
+        meanRect(x1 - band, yA, x1, yB),
+        meanRect(x1 - band * 2, yA, x1 - band, yB),
+        meanRect(x1 - band * 3, yA, x1 - band * 2, yB)
+      ])
+    );
+  }
+  if (card.y + card.h <= img.h - 1 && card.h > band * 4) {
+    const y1 = card.y + card.h;
+    const xA = card.x + card.w * 0.2;
+    const xB = card.x + card.w * 0.8;
+    readings.push(
+      rise([
+        meanRect(xA, y1 - band, xB, y1),
+        meanRect(xA, y1 - band * 2, xB, y1 - band),
+        meanRect(xA, y1 - band * 3, xB, y1 - band * 2)
+      ])
+    );
+  }
+  return readings.length ? Math.max(...readings) : null;
+}
+function edgeContrast(img, ground, card) {
+  const yA = Math.max(0, Math.round(card.y + card.h * 0.2));
+  const yB = Math.min(img.h, Math.round(card.y + card.h * 0.8));
+  const col = (x) => {
+    if (x < 0 || x >= img.w) return 0;
+    const ds = [];
+    const step = Math.max(1, Math.round((yB - yA) / 80));
+    for (let y = yA; y < yB; y += step) ds.push(delta(at(img, x, y), ground));
+    return median(ds);
+  };
+  const depth = Math.min(24, Math.floor(card.w / 8));
+  let best = 0;
+  for (let d = 0; d < depth; d++) {
+    best = Math.max(best, col(card.x + d), col(card.x + card.w - 1 - d));
+  }
+  return best;
+}
+function inkCoverage(img, rect, threshold = 48) {
+  const x0 = Math.max(0, Math.floor(rect.x));
+  const y0 = Math.max(0, Math.floor(rect.y));
+  const x1 = Math.min(img.w, Math.ceil(rect.x + rect.w));
+  const y1 = Math.min(img.h, Math.ceil(rect.y + rect.h));
+  if (x1 - x0 < 2 || y1 - y0 < 2) return 0;
+  const step = Math.max(1, Math.round(Math.max(x1 - x0, y1 - y0) / 300));
+  const r = [];
+  const g = [];
+  const b = [];
+  const pts = [];
+  for (let y = y0; y < y1; y += step) {
+    for (let x = x0; x < x1; x += step) {
+      const p = at(img, x, y);
+      pts.push(p);
+      r.push(p[0]);
+      g.push(p[1]);
+      b.push(p[2]);
+    }
+  }
+  const base = [median(r), median(g), median(b)];
+  let ink = 0;
+  for (const p of pts) if (delta(p, base) > threshold) ink++;
+  return pts.length ? ink / pts.length : 0;
+}
+function differenceHash(img, rect) {
+  const r = rect ?? { x: 0, y: 0, w: img.w, h: img.h };
+  const cols = 9;
+  const rows = 8;
+  const cell = [];
+  for (let cy = 0; cy < rows; cy++) {
+    for (let cx = 0; cx < cols; cx++) {
+      const x0 = Math.floor(r.x + cx * r.w / cols);
+      const x1 = Math.max(x0 + 1, Math.floor(r.x + (cx + 1) * r.w / cols));
+      const y0 = Math.floor(r.y + cy * r.h / rows);
+      const y1 = Math.max(y0 + 1, Math.floor(r.y + (cy + 1) * r.h / rows));
+      let sum = 0;
+      let n = 0;
+      const sx = Math.max(1, Math.floor((x1 - x0) / 8));
+      const sy = Math.max(1, Math.floor((y1 - y0) / 8));
+      for (let y = y0; y < y1 && y < img.h; y += sy) {
+        for (let x = x0; x < x1 && x < img.w; x += sx) {
+          const p = at(img, Math.max(0, x), Math.max(0, y));
+          sum += 0.299 * p[0] + 0.587 * p[1] + 0.114 * p[2];
+          n++;
+        }
+      }
+      cell.push(n ? sum / n : 0);
+    }
+  }
+  let bits = "";
+  for (let cy = 0; cy < rows; cy++) {
+    let byte = 0;
+    for (let cx = 0; cx < cols - 1; cx++) {
+      const l = cell[cy * cols + cx];
+      const rr = cell[cy * cols + cx + 1];
+      byte = byte << 1 | (l > rr ? 1 : 0);
+    }
+    bits += byte.toString(16).padStart(2, "0");
+  }
+  return bits;
+}
+function hammingDistance(a, b) {
+  let d = 0;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    let x = parseInt(a[i], 16) ^ parseInt(b[i], 16);
+    while (x) {
+      d += x & 1;
+      x >>= 1;
+    }
+  }
+  return d + Math.abs(a.length - b.length) * 4;
+}
+function luminance(c) {
+  const lin = (v) => {
+    const s = v / 255;
+    return s <= 0.04045 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  };
+  return 0.2126 * lin(c[0]) + 0.7152 * lin(c[1]) + 0.0722 * lin(c[2]);
+}
+function lightness(c) {
+  const y = luminance(c);
+  return y > 8856e-6 ? 116 * Math.cbrt(y) - 16 : 903.3 * y;
+}
+function medianColour(img, rect) {
+  const r = [];
+  const g = [];
+  const b = [];
+  const x0 = Math.max(0, Math.floor(rect.x));
+  const y0 = Math.max(0, Math.floor(rect.y));
+  const x1 = Math.min(img.w, Math.ceil(rect.x + rect.w));
+  const y1 = Math.min(img.h, Math.ceil(rect.y + rect.h));
+  const step = Math.max(1, Math.round(Math.max(x1 - x0, y1 - y0) / 200));
+  for (let y = y0; y < y1; y += step) {
+    for (let x = x0; x < x1; x += step) {
+      const p = at(img, x, y);
+      r.push(p[0]);
+      g.push(p[1]);
+      b.push(p[2]);
+    }
+  }
+  return [median(r), median(g), median(b)];
+}
+function edgeEnergy(img, width) {
+  const cols = Math.max(2, Math.min(width, img.w));
+  const rows = Math.max(2, Math.round(cols * img.h / img.w));
+  const lum = [];
+  for (let cy = 0; cy < rows; cy++) {
+    for (let cx = 0; cx < cols; cx++) {
+      const x = Math.min(img.w - 1, Math.floor((cx + 0.5) * img.w / cols));
+      const y = Math.min(img.h - 1, Math.floor((cy + 0.5) * img.h / rows));
+      const p = at(img, x, y);
+      lum.push(0.299 * p[0] + 0.587 * p[1] + 0.114 * p[2]);
+    }
+  }
+  let sum = 0;
+  let n = 0;
+  for (let cy = 0; cy < rows; cy++) {
+    for (let cx = 1; cx < cols; cx++) {
+      sum += Math.abs(lum[cy * cols + cx] - lum[cy * cols + cx - 1]);
+      n++;
+    }
+  }
+  return n ? sum / n : 0;
+}
+function measureStill(img) {
+  const g = groundColour(img);
+  const strong = cardBounds(img, g, 60);
+  const faint = cardBounds(img, g, 12) ?? strong;
+  const card = faint;
+  const bleed = [];
+  let pad = null;
+  let widthPct = null;
+  let shadow = null;
+  let edge = 0;
+  let separation = null;
+  if (card) {
+    pad = {
+      left: card.x / img.w,
+      right: (img.w - card.x - card.w) / img.w,
+      top: card.y / img.h,
+      bottom: (img.h - card.y - card.h) / img.h
+    };
+    for (const side of ["left", "right", "top", "bottom"])
+      if (pad[side] < 5e-3) bleed.push(side);
+    widthPct = card.w / img.w;
+    shadow = haloReading(img, g, card);
+    edge = edgeContrast(img, g, card);
+    const body = strong ?? card;
+    const inner = {
+      x: body.x + body.w * 0.1,
+      y: body.y + body.h * 0.1,
+      w: body.w * 0.8,
+      h: body.h * 0.8
+    };
+    separation = Math.abs(lightness(medianColour(img, inner)) - lightness(g));
+  }
+  const inkRect = strong ?? card ?? { x: 0, y: 0, w: img.w, h: img.h };
+  return {
+    w: img.w,
+    h: img.h,
+    ground: hex(g),
+    card,
+    widthPct,
+    pad,
+    bleed,
+    shadow,
+    edge,
+    ink: inkCoverage(img, inkRect),
+    separation,
+    hash: differenceHash(img, inkRect)
+  };
+}
+
+// src/plugin/moments.ts
+var STEP_SETTLE_SECONDS = 0.4;
+var NOT_A_GESTURE = /* @__PURE__ */ new Set(["wait", "goto", "sleep"]);
+function momentCandidates(doc, duration) {
+  const rated = ratedSegments3(doc);
+  const out = [];
+  const push = (c) => {
+    if (c.time < 0 || c.time > duration) return;
+    if (out.some((o) => Math.abs(o.time - c.time) < 0.25)) return;
+    out.push(c);
+  };
+  const steps = doc.source.meta.steps ?? [];
+  for (let i = 0; i < steps.length; i++) {
+    const s = steps[i];
+    if (s.skipped || NOT_A_GESTURE.has(s.do)) continue;
+    const t = stepOutputTime(rated, s, settleAfter(steps, i));
+    if (t === null) continue;
+    push({ time: t, source: "step", step: s.id ?? s.step });
+  }
+  let dropped = 0;
+  const apexes = [];
+  for (const z of doc.zoom) {
+    const ext = spanOutputExtent3(rated, z.in, z.out);
+    if (ext) apexes.push((ext.start + ext.end) / 2);
+    else dropped++;
+  }
+  for (const t of apexes.sort((a, b) => a - b))
+    push({ time: t, source: "zoom" });
+  if (!out.length) {
+    for (const p of [0.1, 0.3, 0.5, 0.7, 0.9])
+      push({ time: p * duration, source: "spread" });
+  }
+  return { candidates: out, dropped };
+}
+function settleAfter(steps, i) {
+  const next = steps[i + 1];
+  if (next && next.do === "wait" && !next.skipped)
+    return Math.max(0, next.tEnd - steps[i].tEnd);
+  return STEP_SETTLE_SECONDS;
+}
+function stepOutputTime(rated, step, settle) {
+  const src = step.tEnd + settle;
+  const ext = spanOutputExtent3(rated, src, src + 1e-3);
+  if (!ext) return null;
+  return ext.start;
+}
+function resolveStepTime(doc, entry) {
+  const m = /^step:([^+-]+)([+-]\d+(?:\.\d+)?)?$/.exec(entry.trim());
+  if (!m) return null;
+  const key = m[1];
+  const offset = m[2] ? Number(m[2]) : STEP_SETTLE_SECONDS;
+  const steps = doc.source.meta.steps ?? [];
+  const step = steps.find((s) => s.id === key) ?? (/^\d+$/.test(key) ? steps.find((s) => s.step === Number(key)) : void 0);
+  if (!step) {
+    const known = steps.map((s) => s.id ?? String(s.step)).filter((s) => s.length);
+    throw new Error(
+      `--times ${entry}: no step "${key}" in the take's step timeline${known.length ? ` (steps: ${known.join(", ")})` : " (the take carries none: record it with the current CLI)"}`
+    );
+  }
+  const t = stepOutputTime(ratedSegments3(doc), step, offset);
+  if (t === null)
+    throw new Error(
+      `--times ${entry}: step "${key}" (${step.tEnd.toFixed(2)}s in the recording) falls outside the cut`
+    );
+  return t;
+}
+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 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 kept = [];
+  const dropped = [];
+  for (const m of measured) {
+    if (m.ink < floor) {
+      dropped.push(
+        `blank at ${m.time.toFixed(2)}s: ${Math.round(m.ink * 100)}% ink (the floor is ${Math.round(floor * 100)}%; the take's median is ${Math.round(median2 * 100)}%)`
+      );
+      continue;
+    }
+    const twin = kept.find((k) => hammingDistance(k.hash, m.hash) <= bits);
+    if (twin) {
+      dropped.push(
+        `${m.time.toFixed(2)}s is the same frame as ${twin.time.toFixed(2)}s`
+      );
+      continue;
+    }
+    kept.push(m);
+  }
+  if (!kept.length && measured.length) {
+    const best = [...measured].sort((a, b) => b.ink - a.ink)[0];
+    kept.push(best);
+    dropped.push(
+      `every candidate is under the blank floor; kept ${best.time.toFixed(2)}s (${Math.round(best.ink * 100)}% ink) as the least empty`
+    );
+  }
+  return { times: kept.map((k) => k.time), dropped };
+}
+
+// src/plugin/shotBake.ts
+import { deflateSync } from "zlib";
+function blurPlane(src, w, h, r, passes = 3) {
+  if (r < 1) return;
+  const tmp = new Float32Array(src.length);
+  for (let p = 0; p < passes; p++) {
+    for (let y = 0; y < h; y++) {
+      let acc = 0;
+      const row = y * w;
+      for (let x = -r; x <= r; x++) acc += src[row + Math.min(w - 1, Math.max(0, x))];
+      for (let x = 0; x < w; x++) {
+        tmp[row + x] = acc / (2 * r + 1);
+        const add = src[row + Math.min(w - 1, x + r + 1)];
+        const sub = src[row + Math.max(0, x - r)];
+        acc += add - sub;
+      }
+    }
+    for (let x = 0; x < w; x++) {
+      let acc = 0;
+      for (let y = -r; y <= r; y++) acc += tmp[Math.min(h - 1, Math.max(0, y)) * w + x];
+      for (let y = 0; y < h; y++) {
+        src[y * w + x] = acc / (2 * r + 1);
+        const add = tmp[Math.min(h - 1, y + r + 1) * w + x];
+        const sub = tmp[Math.max(0, y - r) * w + x];
+        acc += add - sub;
+      }
+    }
+  }
+}
+function roundedCoverage(x, y, rect, r) {
+  let inside = 0;
+  for (const dy of [0.25, 0.75]) {
+    for (const dx of [0.25, 0.75]) {
+      const px = x + dx;
+      const py = y + dy;
+      if (px < rect.x || py < rect.y || px > rect.x + rect.w || py > rect.y + rect.h) continue;
+      const cx = Math.min(Math.max(px, rect.x + r), rect.x + rect.w - r);
+      const cy = Math.min(Math.max(py, rect.y + r), rect.y + rect.h - r);
+      if ((px - cx) ** 2 + (py - cy) ** 2 <= r * r) inside++;
+    }
+  }
+  return inside / 4;
+}
+function bakeShot(shot, opts = {}) {
+  const margin = Math.round(shot.w * (opts.margin ?? 0.06));
+  const radius = shot.w * (opts.radius ?? 0.014);
+  const shadowA = opts.shadow ?? 0.38;
+  const blur = Math.round(shot.w * (opts.blur ?? 0.03));
+  const offsetY = Math.round(shot.w * (opts.offsetY ?? 0.012));
+  const hair = opts.hairline ?? 0;
+  const w = shot.w + margin * 2;
+  const h = shot.h + margin * 2;
+  const out = new Uint8Array(w * h * 4);
+  const rect = { x: margin, y: margin, w: shot.w, h: shot.h };
+  if (shadowA > 0) {
+    const mask = new Float32Array(w * h);
+    for (let y = 0; y < h; y++)
+      for (let x = 0; x < w; x++) {
+        const c = roundedCoverage(x, y - offsetY, rect, radius);
+        if (c > 0) mask[y * w + x] = c;
+      }
+    blurPlane(mask, w, h, Math.max(1, Math.round(blur / 2)));
+    for (let i = 0; i < w * h; i++) {
+      const a = mask[i] * shadowA;
+      if (a <= 2e-3) continue;
+      out[i * 4] = 0;
+      out[i * 4 + 1] = 0;
+      out[i * 4 + 2] = 0;
+      out[i * 4 + 3] = Math.round(a * 255);
+    }
+  }
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const cov = roundedCoverage(x, y, rect, radius);
+      if (cov <= 0) continue;
+      const sx = Math.min(shot.w - 1, Math.max(0, x - margin));
+      const sy = Math.min(shot.h - 1, Math.max(0, y - margin));
+      const si = (sy * shot.w + sx) * 4;
+      const o = (y * w + x) * 4;
+      let r = shot.data[si];
+      let g = shot.data[si + 1];
+      let b = shot.data[si + 2];
+      if (hair > 0) {
+        const edge = Math.min(x - rect.x, rect.x + rect.w - x, y - rect.y, rect.y + rect.h - y);
+        if (edge < 1.5) {
+          r = Math.round(r * (1 - hair));
+          g = Math.round(g * (1 - hair));
+          b = Math.round(b * (1 - hair));
+        }
+      }
+      const a = cov;
+      const ba = out[o + 3] / 255;
+      const outA = a + ba * (1 - a);
+      const mix = (fg, bg) => outA > 0 ? Math.round((fg * a + bg * ba * (1 - a)) / outA) : 0;
+      out[o] = mix(r, out[o]);
+      out[o + 1] = mix(g, out[o + 1]);
+      out[o + 2] = mix(b, out[o + 2]);
+      out[o + 3] = Math.round(outA * 255);
+    }
+  }
+  return { w, h, data: out };
+}
+var crcTable = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(buf) {
+  let c = 4294967295;
+  for (const b of buf) c = crcTable[(c ^ b) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+function chunk(type, body) {
+  const out = new Uint8Array(12 + body.length);
+  const dv = new DataView(out.buffer);
+  dv.setUint32(0, body.length);
+  for (let i = 0; i < 4; i++) out[4 + i] = type.charCodeAt(i);
+  out.set(body, 8);
+  dv.setUint32(8 + body.length, crc32(out.subarray(4, 8 + body.length)));
+  return out;
+}
+function encodePng(img) {
+  const stride = img.w * 4;
+  const raw = new Uint8Array((stride + 1) * img.h);
+  for (let y = 0; y < img.h; y++) {
+    raw[y * (stride + 1)] = 2;
+    for (let i = 0; i < stride; i++) {
+      const cur = img.data[y * stride + i];
+      const up = y ? img.data[(y - 1) * stride + i] : 0;
+      raw[y * (stride + 1) + 1 + i] = cur - up & 255;
+    }
+  }
+  const ihdr = new Uint8Array(13);
+  const dv = new DataView(ihdr.buffer);
+  dv.setUint32(0, img.w);
+  dv.setUint32(4, img.h);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+  const parts = [
+    new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]),
+    chunk("IHDR", ihdr),
+    chunk("IDAT", new Uint8Array(deflateSync(raw))),
+    chunk("IEND", new Uint8Array(0))
+  ];
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+
+// src/plugin/template.ts
+function templateOf(config) {
+  const t = config.template;
+  if (!t || typeof t !== "object") return null;
+  return t;
+}
+function aspectOf(size) {
+  const r = size.w / Math.max(1, size.h);
+  if (r > 1.15) return "landscape";
+  if (r < 0.87) return "portrait";
+  return "square";
+}
+function templateProblems(config) {
+  const t = templateOf(config);
+  if (!t) return ["no template block: a poster template declares config.template"];
+  const out = [];
+  const elements = Array.isArray(config.elements) ? config.elements : [];
+  const byId = new Map(elements.filter((e) => e.id).map((e) => [e.id, e]));
+  const params = Array.isArray(config.params) ? config.params : [];
+  const keys = new Set(params.map((p) => p.key).filter(Boolean));
+  if (!t.family) out.push("template.family is missing");
+  for (const s of t.slots ?? []) {
+    const el = byId.get(s.id);
+    if (!el) out.push(`template.slots: no element with id "${s.id}"`);
+    else if (el.type !== s.kind)
+      out.push(`template.slots: "${s.id}" is a ${String(el.type)} element, the slot wants ${s.kind}`);
+  }
+  for (const x of t.text ?? []) {
+    const el = byId.get(x.element);
+    if (!el) out.push(`template.text: no element with id "${x.element}"`);
+    else if (el.type !== "text") out.push(`template.text: "${x.element}" is not a text element`);
+    if (!keys.has(x.param)) out.push(`template.text: param "${x.param}" is not declared in config.params`);
+    const bound = el?.content;
+    if (el && (!bound || typeof bound !== "object" || bound.$data !== x.param))
+      out.push(`template.text: "${x.element}" must bind its content to {$data: "${x.param}"}`);
+  }
+  for (const k of t.params?.required ?? []) {
+    if (!keys.has(k)) out.push(`template.params.required: "${k}" is not declared in config.params`);
+  }
+  if (!t.layouts?.landscape) out.push("template.layouts.landscape is required");
+  for (const [name, layout] of Object.entries(t.layouts ?? {})) {
+    for (const s of t.slots ?? []) {
+      if (!layout?.slots?.[s.id]) out.push(`template.layouts.${name}: slot "${s.id}" is not placed`);
+    }
+  }
+  return out;
+}
+var pctOf = (v) => {
+  if (typeof v === "number") return null;
+  if (typeof v !== "string") return null;
+  const m = /^(-?\d+(?:\.\d+)?)%$/.exec(v.trim());
+  return m ? Number(m[1]) / 100 : null;
+};
+function fillTemplate(config, input) {
+  const t = templateOf(config);
+  if (!t) throw new Error("fillTemplate: the config carries no template block");
+  const aspect = aspectOf(input.size);
+  const layout = t.layouts[aspect] ?? t.layouts.landscape;
+  const out = structuredClone(config);
+  const designH = 1080;
+  const designW = designH * input.size.w / input.size.h;
+  const elements = Array.isArray(out.elements) ? out.elements : [];
+  const byId = new Map(elements.filter((e) => e.id).map((e) => [e.id, e]));
+  const slotRects = {};
+  for (const s of t.slots) {
+    const el = byId.get(s.id);
+    const place = layout.slots[s.id];
+    const src = input.slots[s.id];
+    if (!el || !place) continue;
+    if (src) el.src = src.src;
+    const pad = src?.pad ?? 0;
+    slotRects[s.id] = {
+      x: place.x,
+      y: place.y,
+      w: place.w,
+      h: place.w * (input.size.w / input.size.h) / (src?.aspect ?? 16 / 9)
+    };
+    const w = place.w * designW * (1 + 2 * pad);
+    const x = place.x - place.w * pad;
+    const y = place.y - place.w * pad * (input.size.w / input.size.h) / (src?.aspect ?? 16 / 9);
+    el.position = { x: `${(x * 100).toFixed(2)}%`, y: `${(y * 100).toFixed(2)}%` };
+    el.anchor = "top-left";
+    el.size = { ...el.size ?? {}, width: Math.round(w), height: "auto" };
+    if (!src && s.required) el.opacity = 0;
+  }
+  const data = out.data && typeof out.data === "object" ? { ...out.data } : {};
+  const params = Array.isArray(out.params) ? out.params : [];
+  const missing = [];
+  for (const k of [...t.params.required ?? [], ...t.params.brand ?? []]) {
+    if (input.values[k] === void 0 || input.values[k] === null || input.values[k] === "") {
+      if ((t.params.required ?? []).includes(k)) missing.push(k);
+      continue;
+    }
+    data[k] = input.values[k];
+    const p = params.find((q) => q.key === k);
+    if (p) p.default = input.values[k];
+  }
+  for (const [k, v] of Object.entries(input.values)) {
+    if (v !== void 0 && v !== null && v !== "") {
+      data[k] = v;
+      const p = params.find((q) => q.key === k);
+      if (p) p.default = v;
+    }
+  }
+  out.data = data;
+  const boxes = [];
+  for (const x of t.text) {
+    const el = byId.get(x.element);
+    if (!el) continue;
+    const pos = layout.text?.[x.element];
+    if (pos) el.position = { x: pos.x, y: pos.y };
+    const size = layout.size?.[x.element];
+    if (size) el.font = { ...el.font ?? {}, size };
+    if (layout.hide?.includes(x.element)) {
+      el.opacity = 0;
+      continue;
+    }
+    const value = data[x.param];
+    if (typeof value !== "string" || !value.trim()) continue;
+    const font = el.font ?? {};
+    const px = typeof font.size === "number" ? font.size : 40;
+    const lines = value.split("\n");
+    const longest = Math.max(...lines.map((l) => l.length));
+    const lh = typeof font.lineHeight === "number" ? font.lineHeight : 1.15;
+    const boxW = longest * px * 0.56;
+    const boxH = lines.length * px * lh;
+    const ex = pctOf(el.position?.x) ?? 0;
+    const ey = pctOf(el.position?.y) ?? 0;
+    const anchor = String(el.anchor ?? "center");
+    let left = ex * designW;
+    let top = ey * designH;
+    if (anchor.includes("right")) left -= boxW;
+    else if (!anchor.includes("left")) left -= boxW / 2;
+    if (anchor.includes("bottom")) top -= boxH;
+    else if (!anchor.includes("top")) top -= boxH / 2;
+    const rawColor = font.color;
+    const color = typeof rawColor === "string" ? rawColor : rawColor && typeof rawColor === "object" && typeof rawColor.$data === "string" ? data[rawColor.$data] : void 0;
+    boxes.push({
+      x: left / designW,
+      y: top / designH,
+      w: boxW / designW,
+      h: boxH / designH,
+      color: color && /^#[0-9a-f]{6}$/i.test(color) ? color : void 0,
+      role: x.role,
+      label: value.length > 24 ? `${value.slice(0, 24)}\u2026` : value
+    });
+  }
+  for (const id of layout.hide ?? []) {
+    const el = byId.get(id);
+    if (el && !t.text.some((x) => x.element === id)) el.opacity = 0;
+  }
+  return { config: out, text: boxes, slots: slotRects, aspect, missing };
+}
+function textLimitProblems(t, values) {
+  const out = [];
+  for (const x of t.text) {
+    const v = values[x.param];
+    if (typeof v !== "string") continue;
+    const words = v.trim().split(/\s+/).filter(Boolean).length;
+    const lines = v.split("\n").length;
+    if (x.maxWords && words > x.maxWords)
+      out.push(`${x.param}: ${words} words, the template holds ${x.maxWords}`);
+    if (x.lines && lines > x.lines)
+      out.push(`${x.param}: ${lines} lines, the template holds ${x.lines}`);
+  }
+  return out;
+}
+
+// src/plugin/templates/cardOnGradient.ts
+var GROUND = `(ctx) => {
+  const THREE = ctx.THREE
+  const d = ctx.data
+  const canvas = document.createElement('canvas')
+  canvas.width = 1280
+  canvas.height = 720
+  const c = canvas.getContext('2d')
+  c.fillStyle = d.bgA
+  c.fillRect(0, 0, 1280, 720)
+  const blob = (x, y, r, color) => {
+    const g = c.createRadialGradient(x, y, 0, x, y, r)
+    g.addColorStop(0, color)
+    g.addColorStop(1, 'rgba(0,0,0,0)')
+    c.fillStyle = g
+    c.fillRect(0, 0, 1280, 720)
+  }
+  blob(180, 120, 760, d.blobA)
+  blob(1120, 620, 820, d.blobB)
+  blob(760, 60, 620, d.blobC)
+  let seed = 7
+  const rand = () => { seed = (seed * 1664525 + 1013904223) >>> 0; return seed / 4294967296 }
+  const img = c.getImageData(0, 0, 1280, 720)
+  const px = img.data
+  const grain = d.grain
+  for (let i = 0; i < px.length; i += 4) {
+    const n = (rand() - 0.5) * grain
+    px[i] += n; px[i + 1] += n; px[i + 2] += n
+  }
+  c.putImageData(img, 0, 0)
+  const tex = new THREE.CanvasTexture(canvas)
+  tex.colorSpace = THREE.SRGBColorSpace
+  const plane = new THREE.Mesh(
+    new THREE.PlaneGeometry(2, 2),
+    new THREE.MeshBasicMaterial({ map: tex, depthTest: false }),
+  )
+  plane.renderOrder = -10
+  ctx.scene.add(plane)
+  return { refs: { plane }, dispose: () => { tex.dispose(); plane.geometry.dispose(); plane.material.dispose() } }
+}`;
+var TIMELINE = `(ctx, content, duration) => {
+  const { gsap, elements } = ctx
+  const tl = gsap.timeline({ paused: true })
+  const shot = elements.get('shot')
+  if (shot) tl.fromTo(shot.props, { opacity: 0, translateY: 30, scale: 0.97 }, { opacity: 1, translateY: 0, scale: 1, duration: 1.0, ease: 'power3.out' }, 0.2)
+  return tl
+}`;
+function cardOnGradient() {
+  return {
+    version: 2,
+    duration: 4,
+    camera: { preset: "fullscreen" },
+    template: {
+      family: "card-on-gradient",
+      slots: [{ id: "shot", kind: "image", required: true }],
+      params: { required: [], brand: ["bgA", "blobA", "blobB", "blobC", "grain"] },
+      text: [],
+      layouts: {
+        landscape: { slots: { shot: { x: 0.09, y: 0.12, w: 0.82 } } },
+        square: { slots: { shot: { x: 0.08, y: 0.27, w: 0.84 } } },
+        portrait: { slots: { shot: { x: 0.06, y: 0.3, w: 0.88 } } }
+      }
+    },
+    params: [
+      { key: "bgA", type: "color", label: "Ground", default: "#f3efe8" },
+      { key: "blobA", type: "color", label: "Blob A", default: "rgba(255,183,146,0.55)" },
+      { key: "blobB", type: "color", label: "Blob B", default: "rgba(170,196,255,0.5)" },
+      { key: "blobC", type: "color", label: "Blob C", default: "rgba(255,236,170,0.45)" },
+      { key: "grain", type: "number", label: "Grain", default: 14, min: 0, max: 40, step: 1 }
+    ],
+    data: {
+      bgA: "#f3efe8",
+      blobA: "rgba(255,183,146,0.55)",
+      blobB: "rgba(170,196,255,0.5)",
+      blobC: "rgba(255,236,170,0.45)",
+      grain: 14
+    },
+    elements: [
+      {
+        type: "image",
+        id: "shot",
+        src: "",
+        position: { x: "9%", y: "12%" },
+        anchor: "top-left",
+        size: { width: 1574, height: "auto", fit: "contain" },
+        zIndex: 60,
+        opacity: 0
+      }
+    ],
+    createContent: GROUND,
+    createTimeline: TIMELINE
+  };
+}
+
+// src/plugin/templates/splitCover.ts
+var GROUND2 = `(ctx) => {
+  const THREE = ctx.THREE
+  const d = ctx.data
+  const canvas = document.createElement('canvas')
+  canvas.width = 1280
+  canvas.height = 720
+  const c = canvas.getContext('2d')
+  const g = c.createLinearGradient(0, 0, 1280, 720)
+  g.addColorStop(0, d.bgA)
+  g.addColorStop(0.55, d.bgB)
+  g.addColorStop(1, d.bgC)
+  c.fillStyle = g
+  c.fillRect(0, 0, 1280, 720)
+  const rg = c.createRadialGradient(980, 120, 40, 980, 120, 820)
+  rg.addColorStop(0, d.streak)
+  rg.addColorStop(1, 'rgba(0,0,0,0)')
+  c.fillStyle = rg
+  c.fillRect(0, 0, 1280, 720)
+  let seed = 41
+  const rand = () => { seed = (seed * 1664525 + 1013904223) >>> 0; return seed / 4294967296 }
+  const img = c.getImageData(0, 0, 1280, 720)
+  const px = img.data
+  const grain = d.grain
+  for (let i = 0; i < px.length; i += 4) {
+    const n = (rand() - 0.5) * grain
+    px[i] += n; px[i + 1] += n; px[i + 2] += n
+  }
+  c.putImageData(img, 0, 0)
+  const tex = new THREE.CanvasTexture(canvas)
+  tex.colorSpace = THREE.SRGBColorSpace
+  const plane = new THREE.Mesh(
+    new THREE.PlaneGeometry(2, 2),
+    new THREE.MeshBasicMaterial({ map: tex, depthTest: false }),
+  )
+  plane.renderOrder = -10
+  ctx.scene.add(plane)
+  return { refs: { plane }, dispose: () => { tex.dispose(); plane.geometry.dispose(); plane.material.dispose() } }
+}`;
+var TIMELINE2 = `(ctx, content, duration) => {
+  const { gsap, elements } = ctx
+  const tl = gsap.timeline({ paused: true })
+  const kicker = elements.get('kicker')
+  const title = elements.get('title')
+  const brand = elements.get('brand')
+  const shot = elements.get('shot')
+  if (kicker) tl.fromTo(kicker.props, { opacity: 0, translateY: 14 }, { opacity: 1, translateY: 0, duration: 0.7, ease: 'power2.out' }, 0.25)
+  if (title) tl.fromTo(title.props, { opacity: 0, translateY: 26 }, { opacity: 1, translateY: 0, duration: 0.9, ease: 'power3.out' }, 0.45)
+  if (brand) tl.fromTo(brand.props, { opacity: 0 }, { opacity: 1, duration: 0.8, ease: 'power2.out' }, 0.9)
+  if (shot) tl.fromTo(shot.props, { opacity: 0, translateX: 70 }, { opacity: 1, translateX: 0, duration: 1.1, ease: 'power3.out' }, 0.55)
+  return tl
+}`;
+function splitCover() {
+  return {
+    version: 2,
+    duration: 6,
+    camera: { preset: "fullscreen" },
+    fonts: [
+      { family: "Fraunces", url: "https://assets.vos.so/fonts/fraunces/600.woff2", weight: 600 },
+      { family: "Lexend", url: "https://assets.vos.so/fonts/lexend/700.woff2", weight: 700 },
+      { family: "JetBrains Mono", url: "https://assets.vos.so/fonts/jetbrains-mono/400.woff2", weight: 400 }
+    ],
+    template: {
+      family: "split-cover",
+      slots: [{ id: "shot", kind: "image", required: true }],
+      params: {
+        required: ["headline", "brand"],
+        brand: ["bgA", "bgB", "bgC", "ink", "inkSoft", "accent", "streak", "fontDisplay", "fontBody", "grain"]
+      },
+      text: [
+        { element: "title", param: "headline", role: "headline", maxWords: 8, lines: 3 },
+        { element: "kicker", param: "kicker", role: "body" },
+        { element: "brand", param: "brand", role: "body" }
+      ],
+      layouts: {
+        landscape: {
+          slots: { shot: { x: 0.46, y: 0.28, w: 1.02 } },
+          text: { kicker: { x: "7%", y: "24%" }, title: { x: "7%", y: "44%" }, brand: { x: "7%", y: "86%" } },
+          size: { title: 84, kicker: 19, brand: 25 }
+        },
+        square: {
+          slots: { shot: { x: 0.1, y: 0.5, w: 1 } },
+          text: { kicker: { x: "8%", y: "12%" }, title: { x: "8%", y: "27%" }, brand: { x: "8%", y: "93%" } },
+          size: { title: 72, kicker: 18, brand: 23 }
+        },
+        portrait: {
+          slots: { shot: { x: 0.08, y: 0.44, w: 1.06 } },
+          text: { kicker: { x: "8%", y: "12%" }, title: { x: "8%", y: "26%" }, brand: { x: "8%", y: "94%" } },
+          size: { title: 64, kicker: 17, brand: 22 }
+        }
+      }
+    },
+    params: [
+      { key: "kicker", type: "text", label: "Kicker", default: "RELEASE" },
+      { key: "headline", type: "text", label: "Headline", default: "What shipped,\nin three lines" },
+      { key: "brand", type: "text", label: "Wordmark", default: "brand" },
+      { key: "bgA", type: "color", label: "Ground A", default: "#8a3d2a" },
+      { key: "bgB", type: "color", label: "Ground B", default: "#c0632f" },
+      { key: "bgC", type: "color", label: "Ground C", default: "#5c5a2e" },
+      { key: "ink", type: "color", label: "Ink", default: "#fff6ec" },
+      { key: "inkSoft", type: "color", label: "Ink, softened", default: "#e9d9c8" },
+      { key: "streak", type: "color", label: "Light streak", default: "rgba(255,220,170,0.18)" },
+      { key: "fontDisplay", type: "text", label: "Headline face", default: "Fraunces, serif" },
+      { key: "fontBody", type: "text", label: "Body face", default: "Lexend, sans-serif" },
+      { key: "grain", type: "number", label: "Grain", default: 22, min: 0, max: 40, step: 1 }
+    ],
+    data: {
+      kicker: "RELEASE",
+      headline: "What shipped,\nin three lines",
+      brand: "brand",
+      bgA: "#8a3d2a",
+      bgB: "#c0632f",
+      bgC: "#5c5a2e",
+      ink: "#fff6ec",
+      inkSoft: "#e9d9c8",
+      streak: "rgba(255,220,170,0.18)",
+      fontDisplay: "Fraunces, serif",
+      fontBody: "Lexend, sans-serif",
+      grain: 22
+    },
+    elements: [
+      {
+        type: "text",
+        id: "kicker",
+        content: { $data: "kicker" },
+        position: { x: "7%", y: "24%" },
+        anchor: "center-left",
+        font: { family: "JetBrains Mono, monospace", size: 19, weight: 400, color: { $data: "inkSoft" }, letterSpacing: 6, align: "left" },
+        opacity: 0
+      },
+      {
+        type: "text",
+        id: "title",
+        content: { $data: "headline" },
+        position: { x: "7%", y: "44%" },
+        anchor: "center-left",
+        font: { family: { $data: "fontDisplay" }, size: 84, weight: 600, color: { $data: "ink" }, lineHeight: 1.08, align: "left", letterSpacing: 0 },
+        opacity: 0
+      },
+      {
+        type: "text",
+        id: "brand",
+        content: { $data: "brand" },
+        position: { x: "7%", y: "86%" },
+        anchor: "center-left",
+        font: { family: { $data: "fontBody" }, size: 25, weight: 700, color: { $data: "ink" }, letterSpacing: 1, align: "left" },
+        opacity: 0
+      },
+      {
+        type: "image",
+        id: "shot",
+        src: "",
+        position: { x: "46%", y: "28%" },
+        anchor: "top-left",
+        size: { width: 1400, height: "auto", fit: "contain" },
+        zIndex: 60,
+        opacity: 0
+      }
+    ],
+    createContent: GROUND2,
+    createTimeline: TIMELINE2
+  };
+}
+
+// src/plugin/templates/index.ts
+var TEMPLATES = {
+  "split-cover": splitCover,
+  "card-on-gradient": cardOnGradient
+};
+var TEMPLATE_NAMES = Object.keys(TEMPLATES);
+function templateByName(name) {
+  const make = TEMPLATES[name];
+  return make ? make() : null;
+}
+
+// src/plugin/posterValues.ts
+import {
+  findFontFamily as findFontFamily2,
+  fontFaceUrl,
+  fontStack,
+  nearestFontWeight
+} from "@vosjs/shared";
+var HEX = /^#([0-9a-f]{6})$/i;
+var rgb = (hex2) => {
+  const m = HEX.exec(hex2.trim());
+  if (!m) return null;
+  const n = parseInt(m[1], 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+};
+var toHex = (c) => "#" + c.map((v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0")).join("");
+function mixHex(a, b, t) {
+  const pa = rgb(a);
+  const pb = rgb(b);
+  if (!pa || !pb) return a;
+  return toHex([pa[0] + (pb[0] - pa[0]) * t, pa[1] + (pb[1] - pa[1]) * t, pa[2] + (pb[2] - pa[2]) * t]);
+}
+function rgba(hex2, alpha) {
+  const c = rgb(hex2) ?? [255, 255, 255];
+  return `rgba(${c[0]},${c[1]},${c[2]},${alpha})`;
+}
+function isLightHex(hex2) {
+  const c = rgb(hex2);
+  if (!c) return true;
+  return (0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2]) / 255 >= 0.6;
+}
+function resolveFace(family, weights) {
+  if (!family) return null;
+  const first = family.split(",")[0].replace(/['"]/g, "").replace(/\s+variable$/i, "").trim();
+  const entry = findFontFamily2(first);
+  if (!entry) return null;
+  const fonts = [...new Set(weights.map((w) => nearestFontWeight(entry, w)))].map((w) => ({
+    family: entry.family,
+    url: fontFaceUrl(entry.slug, w),
+    weight: w
+  }));
+  return { stack: fontStack(entry), fonts };
+}
+function posterValues(brand, words) {
+  const b = brand ?? {};
+  const bgA = b.bgA && HEX.test(b.bgA) ? b.bgA : null;
+  const bgB = b.bgB && HEX.test(b.bgB) ? b.bgB : bgA;
+  const bgC = b.bgC && HEX.test(b.bgC) ? b.bgC : bgB;
+  const ink = b.ink && HEX.test(b.ink) ? b.ink : null;
+  const accent = b.accent && HEX.test(b.accent) ? b.accent : null;
+  const wordmark = (words.brand ?? b.wordmark ?? b.name ?? "").trim();
+  const release = (words.release ?? "").trim();
+  const lightGround = bgA ? isLightHex(bgA) : false;
+  const values = {};
+  if (bgA) values.bgA = bgA;
+  if (bgB) values.bgB = bgB;
+  if (bgC) values.bgC = bgC;
+  if (ink) values.ink = ink;
+  if (accent) values.accent = accent;
+  if (ink && bgA) values.inkSoft = mixHex(ink, bgA, 0.28);
+  if (accent) values.streak = rgba(accent, lightGround ? 0.12 : 0.18);
+  if (bgA) values.grain = lightGround ? 10 : 22;
+  if (accent) values.blobA = rgba(accent, lightGround ? 0.28 : 0.4);
+  if (bgC) values.blobB = rgba(bgC, 0.75);
+  if (accent) values.blobC = rgba(mixHex(accent, "#ffffff", 0.55), lightGround ? 0.35 : 0.25);
+  if (wordmark) values.brand = wordmark;
+  const headline = (words.headline ?? "").trim();
+  if (headline) values.headline = headline;
+  const kicker = (words.kicker ?? "").trim();
+  values.kicker = kicker ? kicker : [wordmark, release].filter(Boolean).join("  ").toUpperCase();
+  const fonts = [];
+  const display = resolveFace(b.fontDisplay, [600, 700]);
+  if (display) {
+    values.fontDisplay = display.stack;
+    fonts.push(...display.fonts);
+  }
+  const body = resolveFace(b.fontBody, [700]);
+  if (body) {
+    values.fontBody = body.stack;
+    fonts.push(...body.fonts);
+  }
+  return { values, fonts, lightGround };
+}
+
+// src/plugin/motionPlan.ts
+import { ratedSegments as ratedSegments4, spanOutputExtent as spanOutputExtent4 } from "@vosjs/studio-core";
+var SOUND_DESTINATIONS = /* @__PURE__ */ new Set([
+  "x-feed-cut",
+  "youtube-main-demo",
+  "shorts-linkedin-vertical-cut"
+]);
+var LOOP_DESTINATIONS = /* @__PURE__ */ new Set(["github-readme-loop"]);
+var off = (v) => v !== void 0 && /^(none|off|false|no)$/i.test(v.trim());
+function pickTrack(catalog, ask) {
+  if (!catalog || !ask || off(ask)) return null;
+  const want = ask.trim().toLowerCase();
+  return catalog.tracks.find((t) => t.slug.toLowerCase() === want) ?? catalog.tracks.find((t) => (t.mood ?? "").toLowerCase() === want) ?? null;
+}
+function clickTimes(doc, range) {
+  const rated = ratedSegments4(doc);
+  const out = [];
+  for (const e of doc.source.cursor) {
+    if (e.type !== "down") continue;
+    const src = e.t / 1e3;
+    const ext = spanOutputExtent4(rated, src, src + 1e-3);
+    if (!ext) continue;
+    const t = ext.start;
+    if (t < range[0] || t > range[1]) continue;
+    if (out.length && t - out[out.length - 1] < 0.12) continue;
+    out.push(+(t - range[0]).toFixed(3));
+  }
+  return out;
+}
+function planMotion(input) {
+  const { destination: d, doc, range, words, launch, catalog } = input;
+  const set = [];
+  const notes = [];
+  const skipped = [];
+  if (d.kind !== "video") return { set, notes, skipped };
+  const loop = LOOP_DESTINATIONS.has(d.id);
+  const sound = SOUND_DESTINATIONS.has(d.id);
+  const length = range[1] - range[0];
+  const portrait = d.px.w / d.px.h < 0.9;
+  const entrance = launch.entrance;
+  if (!loop && !off(entrance)) {
+    const kind = entrance && /^(tilt-in|pull-out|rise)$/.test(entrance.trim()) ? entrance.trim() : "tilt-in";
+    set.push(`frame.entrance={"kind":"${kind}"}`);
+    notes.push(`entrance ${kind}`);
+  }
+  if (!loop && !off(launch.endCard)) {
+    const headline = (words.headline ?? "").trim();
+    const brand = (words.brand ?? "").trim();
+    const sub = [brand, (words.release ?? "").trim()].filter(Boolean).join(" ");
+    if (headline || brand) {
+      const card = { seconds: 2.5 };
+      if (input.ink) card.ink = input.ink;
+      if (headline) card.headline = headline;
+      if (sub && sub !== headline) card.sub = sub;
+      if (brand) card.wordmark = brand;
+      set.push(`endCard=${JSON.stringify(card)}`);
+      notes.push("end card");
+    } else {
+      skipped.push(`${d.id}: no end card (no headline or wordmark in LAUNCH.md, BRAND.md or the flags)`);
+    }
+  }
+  if (!loop && d.text !== "none" && input.captions.length && !off(launch.captions)) {
+    const rated = ratedSegments4(doc);
+    const steps = doc.source.meta.steps ?? [];
+    const clips = [];
+    for (const c of input.captions) {
+      const step = steps.find((s) => c.id !== void 0 && s.id === c.id || s.step === c.step);
+      if (!step || step.skipped) continue;
+      const t = stepOutputTime(rated, step, 0.2);
+      if (t === null || t < range[0] || t > range[1] - 1) continue;
+      const start = +(t - range[0]).toFixed(3);
+      clips.push({
+        id: `caption-${c.step}`,
+        kind: "text",
+        text: c.caption,
+        preset: "caption",
+        start,
+        duration: Math.min(3.5, Math.max(2.5, range[1] - t - 0.2)),
+        transform: { x: 0.5, y: portrait ? 0.8 : 0.86, scale: 1, rotation: 0 },
+        enter: "rise",
+        exit: "fade",
+        align: "center",
+        box: { color: "rgba(17,17,17,0.72)" }
+      });
+    }
+    if (clips.length) {
+      const existing = Array.isArray(doc.overlays) ? doc.overlays : [];
+      set.push(`overlays=${JSON.stringify([...existing, ...clips])}`);
+      notes.push(`${clips.length} caption(s)`);
+    }
+  }
+  if (sound && !loop) {
+    const track = pickTrack(catalog, launch.music);
+    const clips = Array.isArray(doc.audio) ? [...doc.audio] : [];
+    if (track) {
+      const hasMic = !!doc.source.micKey;
+      const fadeOut = Math.min(2.5, length * 0.15);
+      clips.push({
+        id: "bed",
+        key: track.url,
+        name: track.title,
+        start: 0,
+        in: 0,
+        out: Math.min(track.duration, length),
+        duration: track.duration,
+        gain: hasMic ? 0.35 : 0.5,
+        fadeIn: 0.6,
+        fadeOut,
+        loop: track.duration < length,
+        loopLen: track.duration < length ? length : void 0,
+        duck: hasMic
+      });
+      notes.push(`bed ${track.slug}`);
+    } else if (launch.music && !off(launch.music)) {
+      skipped.push(`${d.id}: music "${launch.music}" is not a catalog track or mood${catalog ? "" : " (the catalog could not be read)"}`);
+    }
+    const click = catalog?.sfx.find((s) => s.slug === "sfx-click");
+    if (click && !doc.source.micKey && !off(launch.clicks)) {
+      const times = clickTimes(doc, range);
+      for (const [i, t] of times.entries()) {
+        clips.push({
+          id: `click-${i}`,
+          key: click.url,
+          name: click.title,
+          start: t,
+          in: 0,
+          out: click.duration,
+          duration: click.duration,
+          gain: 0.4,
+          fadeIn: 0,
+          fadeOut: 0
+        });
+      }
+      if (times.length) notes.push(`${times.length} click sound(s)`);
+    }
+    if (clips.length) set.push(`audio=${JSON.stringify(clips)}`);
+  }
+  if (portrait) {
+    set.push("frame.fit=cover");
+    set.push('frame.inset={"left":0.06,"right":0.06,"top":0.17,"bottom":0.17}');
+    set.push("frame.focusFollow=camera");
+    notes.push("vertical reframe follows the camera");
+  }
+  return { set, notes, skipped };
+}
+
 // src/plugin/deliver.ts
 var CHANNEL_ALIASES = {
   ph: "producthunt",
@@ -2743,20 +4166,153 @@ function resolveChannels(raw) {
   }
   return out;
 }
-function defaultStillTimes(doc, duration) {
-  const rated = ratedSegments3(doc);
-  const apexes = [];
-  for (const z of doc.zoom) {
-    const ext = spanOutputExtent3(rated, z.in, z.out);
-    if (ext) apexes.push((ext.start + ext.end) / 2);
+async function readBrandBesideTake(dir, explicit) {
+  const candidates = explicit ? [explicit] : [join5(dir, "BRAND.md"), join5(dir, "..", "BRAND.md")];
+  for (const file of candidates) {
+    if (!existsSync5(file)) continue;
+    const roles = parseFrontmatter(await readFile5(file, "utf8"));
+    return { file, roles };
+  }
+  return null;
+}
+async function readLaunchBesideTake(dir, explicit) {
+  const candidates = explicit ? [explicit] : [join5(dir, "LAUNCH.md"), join5(dir, "..", "LAUNCH.md")];
+  for (const file of candidates) {
+    if (!existsSync5(file)) continue;
+    return { file, roles: parseFrontmatter(await readFile5(file, "utf8")) };
+  }
+  return null;
+}
+async function resolveLook(dir, opts) {
+  const brand = await readBrandBesideTake(dir, opts.brand);
+  const roles = brand?.roles ?? null;
+  if (opts.look === "none") return { look: null, from: "--look none", roles };
+  if (opts.look !== void 0) {
+    if (!isLookKind(opts.look))
+      throw new Error(
+        `--look "${opts.look}" \u2014 one of plate | gradient | dark | none`
+      );
+    return { look: houseLook(opts.look), from: `--look ${opts.look}`, roles };
+  }
+  if (brand) {
+    const look = lookFromBrand(brand.roles);
+    return { look, from: `${brand.file} (${look.kind})`, roles };
   }
-  const dropped = doc.zoom.length - apexes.length;
-  if (apexes.length) return { times: apexes.sort((a, b) => a - b), dropped };
   return {
-    times: [0.1, 0.3, 0.5, 0.7, 0.9].map((p) => p * duration),
-    dropped
+    look: houseLook("gradient"),
+    from: "the house gradient (no BRAND.md beside the take)",
+    roles
   };
 }
+function templateForCard(d, opts) {
+  if (opts.poster === null) return null;
+  if (opts.poster) return { config: opts.poster.config, from: opts.poster.from };
+  if (!d.template) return null;
+  let name = d.template;
+  let note;
+  const wants = templateOf(templateByName(name) ?? {});
+  const needsHeadline = wants?.text.some((t) => t.role === "headline");
+  if (needsHeadline && !opts.words?.headline?.trim()) {
+    name = "card-on-gradient";
+    note = `${d.id}: no headline (LAUNCH.md headline: or --headline), so the ${d.template} template stands down for card-on-gradient`;
+  }
+  const config = templateByName(name);
+  if (!config) return null;
+  return { config, from: `template ${name}`, note };
+}
+function lookOverrides(look, placement, size, video, opts) {
+  const inset = cardInset(look, size, video, placement);
+  const set = [
+    "frame.fit=contain",
+    `frame.background=${JSON.stringify(look.ground)}`,
+    `frame.inset=${JSON.stringify(inset)}`,
+    `frame.radius=${look.radius}`,
+    `frame.shadow=${look.shadow}`,
+    `frame.shadowContact=${look.shadowContact}`,
+    `frame.border=${look.border}`
+  ];
+  if (look.shadowColor) set.push(`frame.shadowColor=${look.shadowColor}`);
+  if (look.border > 0) {
+    set.push("frame.borderWidth=1");
+    set.push(`frame.borderColor=${look.borderColor ?? "#000000"}`);
+  }
+  if (!opts.keepMedia) set.push("frame.backgroundMedia=null");
+  if (opts.still) {
+    set.push("zoom=[]", "tilt=[]", "cursor.visible=false", "cursor.clickFx.style=none");
+  }
+  return set;
+}
+function endCardInk(look, brand) {
+  if (!look) return null;
+  const ground = look.ground;
+  const m = /#([0-9a-f]{6})/i.exec(ground);
+  const hex2 = m ? m[0] : null;
+  const light = look.kind === "plate" || (hex2 ? isLightHexGround(hex2) : look.kind === "gradient");
+  if (!light) return "#ffffff";
+  const ink = brand?.ink;
+  return ink && /^#[0-9a-f]{6}$/i.test(ink) ? ink : "#111111";
+}
+function isLightHexGround(hex2) {
+  const n = parseInt(hex2.slice(1), 16);
+  const r = n >> 16 & 255;
+  const g = n >> 8 & 255;
+  const b = n & 255;
+  return (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255 >= 0.6;
+}
+var PROBE_WIDTH = 640;
+async function pickStillTimes(browser, dir, doc, duration, opts) {
+  const { candidates, dropped } = momentCandidates(doc, duration);
+  const notes = [];
+  if (dropped > 0)
+    notes.push(
+      `${dropped} of ${doc.zoom.length} zoom apex(es) fall outside the cut`
+    );
+  if (!candidates.length) return { times: [], moments: [], notes };
+  const meta = doc.source.meta;
+  const vw = meta.captureWidth ?? meta.width;
+  const vh = meta.captureHeight ?? meta.height;
+  const probeDir = await mkdtemp(join5(tmpdir(), "vos-moments-"));
+  try {
+    const probe = 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),
+      outDir: probeDir,
+      overrides: {
+        ...opts.overrides,
+        set: [...SCREENSHOT_DEFAULTS, ...opts.overrides?.set ?? []]
+      }
+    });
+    const byTime = /* @__PURE__ */ new Map();
+    for (const frame of probe.frames) {
+      const img = decodePng(new Uint8Array(await readFile5(frame.file)));
+      if (!img) continue;
+      const whole = { x: 0, y: 0, w: img.w, h: img.h };
+      byTime.set(+frame.time.toFixed(3), {
+        ink: inkCoverage(img, whole),
+        hash: differenceHash(img, whole)
+      });
+    }
+    const measured = [];
+    for (const c of candidates) {
+      const m = byTime.get(+c.time.toFixed(3));
+      if (m) measured.push({ time: c.time, ...m });
+    }
+    const pick = pickMoments(measured);
+    const kept = candidates.filter((c) => pick.times.includes(c.time));
+    const bySource = (s) => candidates.filter((c) => c.source === s).length;
+    notes.push(
+      `${candidates.length} candidate(s): ${bySource("step")} from steps, ${bySource("zoom")} from zoom apexes, ${bySource("spread")} from the spread; ${kept.length} kept`
+    );
+    return {
+      times: pick.times,
+      moments: kept,
+      notes: [...notes, ...pick.dropped.map((d) => `moment: ${d}`)]
+    };
+  } finally {
+    await rm3(probeDir, { recursive: true, force: true });
+  }
+}
 var overCeiling = (bytes, maxBytes) => `${Math.ceil(bytes / 1024)} KB exceeds the ${Math.floor(maxBytes / 1024)} KB ceiling`;
 var specWords = (d) => {
   const parts = [`${d.px.w}x${d.px.h}`];
@@ -2776,12 +4332,22 @@ var FULL_BLEED = [
   "cursor.clickFx.style=none"
 ];
 var SCREENSHOT_DEFAULTS = [...FULL_BLEED, "zoom=[]", "tilt=[]"];
-function stillOverridesFor(d, opts) {
+function stillOverridesFor(d, opts, video) {
   const set = [];
-  if (d.fit === "cover") set.push("frame.fit=cover");
-  if (d.genre === "screenshot" && !opts.composed)
+  if (d.genre === "screenshot" && !opts.composed) {
+    if (d.fit === "cover") set.push("frame.fit=cover");
     set.push(...SCREENSHOT_DEFAULTS);
-  else if (d.genre === "card" && !opts.composed) set.push(...FULL_BLEED);
+  } else if (d.genre === "card" && !opts.composed && opts.look && video && d.px) {
+    set.push(
+      ...lookOverrides(opts.look, "card", d.px, video, {
+        still: true,
+        keepMedia: opts.overrides?.background !== void 0
+      })
+    );
+  } else {
+    if (d.fit === "cover") set.push("frame.fit=cover");
+    if (d.genre === "card" && !opts.composed) set.push(...FULL_BLEED);
+  }
   set.push(...opts.overrides?.set ?? []);
   if (!set.length) return opts.overrides;
   return { ...opts.overrides, set };
@@ -2790,34 +4356,69 @@ async function deliverTake(browser, dir, opts) {
   const take = await loadTake(dir);
   if (!take.doc) throw new Error(`${dir} has no doc.json \u2014 run plan first`);
   const doc = take.doc;
-  const duration = totalDuration(ratedSegments3(doc));
+  const duration = totalDuration(ratedSegments5(doc));
   const videoSeconds = opts.range ? Math.min(opts.range[1], duration) - Math.min(opts.range[0], duration) : duration;
+  const outDir = resolve3(opts.outDir ?? join5(dir, "kit"));
+  await mkdir4(outDir, { recursive: true });
+  const destinations = opts.channels.flatMap((c) => destinationsForChannel(c));
+  const assets = [];
+  const skipped = [];
   let stillTimes;
+  let moments;
   if (opts.times?.length) {
     stillTimes = opts.times;
+    moments = opts.times.map((time) => ({ time, source: "times" }));
   } else {
-    const derived = defaultStillTimes(doc, duration);
-    stillTimes = derived.times;
-    if (derived.dropped > 0) {
-      opts.onPhase?.(
-        `note: ${derived.dropped} of ${doc.zoom.length} zoom apex(es) fall outside the cut \u2014 pass --times for more moments`
+    opts.onPhase?.("moments (the step timeline, the zoom apexes, the spread)");
+    const picked = await pickStillTimes(browser, dir, doc, duration, opts);
+    stillTimes = picked.times;
+    moments = picked.moments;
+    for (const n of picked.notes) {
+      if (n.startsWith("moment: ")) skipped.push(n);
+      else opts.onPhase?.(`note: ${n}`);
+    }
+  }
+  const meta0 = doc.source.meta;
+  const video = {
+    w: meta0.captureWidth ?? meta0.width,
+    h: meta0.captureHeight ?? meta0.height
+  };
+  const videoOverrides = (d, range) => {
+    const set = [];
+    if (opts.look) {
+      set.push(
+        ...lookOverrides(opts.look, "hero", d.px, video, {
+          still: false,
+          keepMedia: opts.overrides?.background !== void 0
+        })
       );
     }
-  }
-  const outDir = resolve3(opts.outDir ?? join5(dir, "kit"));
-  await mkdir4(outDir, { recursive: true });
-  const destinations = opts.channels.flatMap((c) => destinationsForChannel(c));
-  const assets = [];
-  const skipped = [];
-  const posterCards = opts.poster !== void 0 ? destinations.filter(
-    (d) => d.kind !== "video" && d.genre === "card" && !NOT_FROM_FOOTAGE[d.id]
-  ) : [];
-  const posterCardIds = new Set(posterCards.map((d) => d.id));
-  if (opts.poster && posterCards.length) {
+    const plan = planMotion({
+      destination: d,
+      doc,
+      range: range ?? [0, duration],
+      words: opts.words ?? {},
+      launch: opts.launchRoles ?? {},
+      captions: opts.captions ?? [],
+      catalog: opts.catalog ?? null,
+      ink: endCardInk(opts.look, opts.brandRoles)
+    });
+    set.push(...plan.set);
+    if (plan.notes.length) opts.onPhase?.(`${d.id}: ${plan.notes.join(", ")}`);
+    for (const s of plan.skipped) skipped.push(`note: ${s}`);
+    set.push(...opts.overrides?.set ?? []);
+    if (!set.length) return opts.overrides;
+    return { ...opts.overrides, set };
+  };
+  const cardPlans = destinations.filter((d) => d.kind !== "video" && d.genre === "card" && !NOT_FROM_FOOTAGE[d.id]).map((d) => ({ d, plan: templateForCard(d, opts) })).filter((p) => p.plan !== null);
+  const posterCardIds = new Set(cardPlans.map((p) => p.d.id));
+  for (const p of cardPlans) if (p.plan.note) skipped.push(`note: ${p.plan.note}`);
+  if (cardPlans.length) {
     const meta = doc.source.meta;
     const heroTime = opts.shotTime ?? (stillTimes.length ? stillTimes[0] : duration / 2);
+    const fill = posterValues(opts.brandRoles, opts.words ?? {});
     opts.onPhase?.(
-      `poster shot (full bleed at ${heroTime.toFixed(2)}s) from ${opts.poster.from}`
+      `poster shot (full bleed at ${heroTime.toFixed(2)}s), baked as an object`
     );
     const serveDir = await mkdtemp(join5(tmpdir(), "vos-poster-"));
     try {
@@ -2835,71 +4436,88 @@ async function deliverTake(browser, dir, opts) {
             "frame.shadow=0",
             "frame.border=0",
             "frame.browserBar.kind=none",
+            "cursor.visible=false",
+            "cursor.clickFx.style=none",
             ...opts.overrides?.set ?? []
           ]
         }
       });
-      await copyFile(shot.frames[0].file, join5(serveDir, "shot.png"));
-      const config = structuredClone(opts.poster.config);
-      const elements = Array.isArray(config.elements) ? config.elements : [];
-      const shotEl = elements.find(
-        (e) => e.id === "shot"
-      ) ?? elements.find(
-        (e) => e.type === "image"
-      );
-      if (!shotEl) {
-        skipped.push(
-          `poster ${opts.poster.from}: no image element (id "shot") to carry the release's screenshot \u2014 card destinations kept from the take`
-        );
-        for (const d of posterCards) posterCardIds.delete(d.id);
-      } else {
-        shotEl.src = "/shot.png";
-        const data = config.data && typeof config.data === "object" ? config.data : {};
-        data.shotUrl = "/shot.png";
-        config.data = data;
+      const raw = decodePng(new Uint8Array(await readFile5(shot.frames[0].file)));
+      if (!raw) throw new Error("the poster shot could not be decoded");
+      const PAD = 0.06;
+      const baked = bakeShot(raw, {
+        margin: PAD,
+        hairline: fill.lightGround ? 0.14 : 0,
+        shadow: fill.lightGround ? 0.32 : 0.45
+      });
+      await writeFile6(join5(serveDir, "shot.png"), encodePng(baked));
+      const shotAspect = raw.w / raw.h;
+      for (const { d, plan } of cardPlans) {
+        const problems = templateProblems(plan.config);
+        if (problems.length) {
+          skipped.push(
+            `${d.channel} ${d.asset}: ${plan.from} is not a valid template (${problems[0]}) \u2014 kept from the take`
+          );
+          posterCardIds.delete(d.id);
+          continue;
+        }
+        const filled = fillTemplate(plan.config, {
+          size: d.px,
+          slots: { shot: { src: "/shot.png", aspect: shotAspect, pad: PAD } },
+          values: fill.values
+        });
+        const limits = textLimitProblems(templateOf(plan.config), fill.values);
+        for (const l of limits) skipped.push(`note: ${d.id}: ${l}`);
+        if (filled.missing.length) {
+          skipped.push(
+            `${d.channel} ${d.asset}: ${plan.from} needs ${filled.missing.join(", ")} \u2014 kept from the take`
+          );
+          posterCardIds.delete(d.id);
+          continue;
+        }
+        const config = filled.config;
+        if (fill.fonts.length) {
+          const declared = Array.isArray(config.fonts) ? config.fonts : [];
+          config.fonts = [...declared, ...fill.fonts];
+        }
         const posterDuration = typeof config.duration === "number" ? config.duration : 6;
         const time = Math.min(
           opts.posterTime ?? posterDuration * 0.9,
           Math.max(0, posterDuration - 0.05)
         );
-        opts.onPhase?.(
-          `poster cards (${posterCards.map((d) => d.id).join(", ")}) at ${time.toFixed(2)}s`
-        );
+        opts.onPhase?.(`${d.channel} ${d.asset} (${specWords(d)}) from ${plan.from}, ${filled.aspect}`);
         await renderPosterStills(
           browser,
           config,
           serveDir,
-          posterCards.map((d) => ({
-            name: `${d.id}.png`,
-            width: d.px.w,
-            height: d.px.h
-          })),
+          [{ name: `${d.id}.png`, width: d.px.w, height: d.px.h }],
           time
         );
-        for (const d of posterCards) {
-          const from = join5(serveDir, `${d.id}.png`);
-          const to = join5(outDir, `${d.id}.png`);
-          await rename4(from, to);
-          const bytes = (await stat(to)).size;
-          if (d.maxBytes !== void 0 && bytes > d.maxBytes) {
-            skipped.push(
-              `${d.channel} ${d.asset}: ${overCeiling(bytes, d.maxBytes)} (kept at ${to})`
-            );
-            continue;
-          }
-          assets.push({
-            channel: d.channel,
-            asset: d.asset,
-            destination: d.id,
-            path: relative(outDir, to),
-            w: d.px.w,
-            h: d.px.h,
-            bytes,
-            seconds: null,
-            frameTime: null,
-            source: "poster"
-          });
+        const from = join5(serveDir, `${d.id}.png`);
+        const to = join5(outDir, `${d.id}.png`);
+        await rename4(from, to);
+        const bytes = (await stat(to)).size;
+        if (d.maxBytes !== void 0 && bytes > d.maxBytes) {
+          skipped.push(
+            `${d.channel} ${d.asset}: ${overCeiling(bytes, d.maxBytes)} (kept at ${to})`
+          );
+          continue;
         }
+        assets.push({
+          channel: d.channel,
+          asset: d.asset,
+          destination: d.id,
+          path: relative(outDir, to),
+          w: d.px.w,
+          h: d.px.h,
+          bytes,
+          seconds: null,
+          frameTime: heroTime,
+          source: "poster",
+          template: templateOf(plan.config)?.family ?? plan.from,
+          text: filled.text,
+          shot: filled.slots.shot
+        });
       }
     } finally {
       await rm3(serveDir, { recursive: true, force: true });
@@ -2920,26 +4538,36 @@ async function deliverTake(browser, dir, opts) {
         );
         continue;
       }
+      let range = opts.range;
+      let seconds = videoSeconds;
       if (d.maxSeconds !== void 0 && videoSeconds > d.maxSeconds) {
-        skipped.push(
-          `${label}: spec caps at ${d.maxSeconds}s, the take is ${videoSeconds.toFixed(0)}s \u2014 cut it (--range, or trim segments in doc.json)`
-        );
-        continue;
+        if (LOOP_DESTINATIONS.has(d.id) && !opts.range) {
+          range = [0, d.maxSeconds];
+          seconds = d.maxSeconds;
+          opts.onPhase?.(
+            `note: ${label} takes the first ${d.maxSeconds}s of the ${videoSeconds.toFixed(0)}s take (a loop's cap)`
+          );
+        } else {
+          skipped.push(
+            `${label}: spec caps at ${d.maxSeconds}s, the take is ${videoSeconds.toFixed(0)}s \u2014 cut it (--range, or trim segments in doc.json)`
+          );
+          continue;
+        }
       }
       opts.onPhase?.(`${label} (${specWords(d)})`);
       const outFile = join5(outDir, `${d.id}.${d.format}`);
       const bitrate = d.maxBytes !== void 0 ? Math.min(
         1e7,
-        Math.floor(d.maxBytes * 8 / videoSeconds * 0.85)
+        Math.floor(d.maxBytes * 8 / seconds * 0.85)
       ) : void 0;
       const result = await renderTake(browser, dir, outFile, {
         width: d.px.w,
         height: d.px.h,
         format: "mp4",
         parallel: opts.parallel,
-        range: opts.range,
+        range,
         bitrate,
-        overrides: opts.overrides,
+        overrides: videoOverrides(d, range),
         onProgress: opts.onProgress
       });
       if (d.maxBytes !== void 0 && result.bytes > d.maxBytes) {
@@ -2963,7 +4591,7 @@ async function deliverTake(browser, dir, opts) {
     }
     const wanted = d.kind === "still-set" ? stillTimes.slice(0, d.count?.max ?? stillTimes.length) : stillTimes.slice(0, 1);
     opts.onPhase?.(`${label} (${specWords(d)}, ${wanted.length} still(s))`);
-    const overrides = stillOverridesFor(d, opts);
+    const overrides = stillOverridesFor(d, opts, video);
     const captured = await framesTake(browser, dir, {
       times: wanted,
       width: d.px.w,
@@ -2992,7 +4620,8 @@ async function deliverTake(browser, dir, opts) {
         h: captured.height,
         bytes,
         seconds: null,
-        frameTime: frame.time
+        frameTime: frame.time,
+        ...d.genre === "screenshot" && opts.composed ? { composed: true } : {}
       });
     }
     if (d.count && captured.frames.length < d.count.min) {
@@ -3003,9 +4632,11 @@ async function deliverTake(browser, dir, opts) {
   }
   const kit = {
     release: opts.release ?? null,
+    look: opts.look?.kind ?? null,
     take: dir,
     produced: (/* @__PURE__ */ new Date()).toISOString(),
     specsVerified: CHANNEL_SPECS_VERIFIED,
+    moments,
     skipped,
     assets
   };
@@ -3014,19 +4645,560 @@ async function deliverTake(browser, dir, opts) {
   return { kit, kitFile, outDir };
 }
 
-// src/plugin/validateKit.ts
-import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile5, stat as stat2 } from "fs/promises";
-import { dirname, isAbsolute, join as join6 } from "path";
+// src/plugin/music.ts
+async function fetchMusicCatalog(origin) {
+  const base = origin.replace(/\/+$/, "");
+  const res = await fetch(`${base}/api/music`);
+  if (!res.ok) throw new Error(`GET ${base}/api/music answered ${res.status}`);
+  const body = await res.json();
+  return {
+    tracks: Array.isArray(body.tracks) ? body.tracks : [],
+    sfx: Array.isArray(body.sfx) ? body.sfx : []
+  };
+}
+
+// src/plugin/judge.ts
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
+import { dirname, isAbsolute, join as join6, resolve as resolve4 } from "path";
 import { DESTINATIONS as DESTINATIONS2 } from "@vosjs/studio-core";
-var PNG_SIG = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+var RUBRIC = [
+  "A plate, and room on it: the subject sits at 74 to 89% of the width with headroom; nobody bleeds a window on all four sides.",
+  "The window is an object: rounded corners and a shadow with weight (a soft wide one on a light plate, a tight glow on a dark one).",
+  "It enters: the first frame is not a static, centred, flat window (a tilt-in, a pull-out, a rise).",
+  "The camera zooms to the affordance, holds through the response, and pulls out to show the consequence.",
+  "Beats are cut at stillness; no wipes.",
+  "Content is staged: real data, a populated state, never an empty canvas or a wallpaper.",
+  "The cursor is a character: visible, smoothed, a press on click, never drifting through dead space.",
+  "The last frame is a poster: a resolved state you could ship as the still.",
+  "The message has its own column or its own frame; the headline is two to six words over up to three lines at about 40% of the height; the wordmark is anchored.",
+  "The poster test: would you post this frame as a still, alone?",
+  "The thumbnail test: does it read at half size?",
+  "Name three ways this asset acknowledges THIS product (its data, its state, its brand), not a generic window."
+];
+function rolesFor(asset) {
+  if (asset.source === "poster" && asset.template) return [asset.template];
+  const spec = DESTINATIONS2.find((d) => d.id === asset.destination);
+  if (spec?.kind === "video") {
+    const portrait = spec.px.w < spec.px.h;
+    return portrait ? ["feature-clip", "site-walkthrough"] : ["feature-clip", "site-walkthrough", "feature-clip-dark"];
+  }
+  if (spec?.genre === "card") return ["window-in-scene", "card-on-gradient", "framed-screenshot"];
+  if (spec?.genre === "screenshot") return ["framed-screenshot", "app-session"];
+  return [];
+}
+function resample(img, w, h) {
+  const out = new Uint8Array(w * h * 4);
+  const sx = img.w / w;
+  const sy = img.h / h;
+  for (let y = 0; y < h; y++) {
+    const y0 = Math.floor(y * sy);
+    const y1 = Math.max(y0 + 1, Math.floor((y + 1) * sy));
+    for (let x = 0; x < w; x++) {
+      const x0 = Math.floor(x * sx);
+      const x1 = Math.max(x0 + 1, Math.floor((x + 1) * sx));
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      let a = 0;
+      let n = 0;
+      for (let yy = y0; yy < y1 && yy < img.h; yy++) {
+        for (let xx = x0; xx < x1 && xx < img.w; xx++) {
+          const o2 = (yy * img.w + xx) * 4;
+          r += img.data[o2];
+          g += img.data[o2 + 1];
+          b += img.data[o2 + 2];
+          a += img.data[o2 + 3];
+          n++;
+        }
+      }
+      const o = (y * w + x) * 4;
+      out[o] = n ? r / n : 0;
+      out[o + 1] = n ? g / n : 0;
+      out[o + 2] = n ? b / n : 0;
+      out[o + 3] = n ? a / n : 0;
+    }
+  }
+  return { w, h, data: out };
+}
+function composeSheet(left, right, height = 540, gutter = 32) {
+  const lw = Math.max(1, Math.round(left.w * height / left.h));
+  const rw = Math.max(1, Math.round(right.w * height / right.h));
+  const L = resample(left, lw, height);
+  const R = resample(right, rw, height);
+  const margin = 24;
+  const band = 8;
+  const w = margin * 2 + lw + gutter + rw;
+  const h = margin * 2 + height + band + 6;
+  const out = new Uint8Array(w * h * 4);
+  for (let i = 0; i < w * h; i++) {
+    out[i * 4] = 240;
+    out[i * 4 + 1] = 242;
+    out[i * 4 + 2] = 244;
+    out[i * 4 + 3] = 255;
+  }
+  const blit = (src, x0, y0) => {
+    for (let y = 0; y < src.h; y++) {
+      for (let x = 0; x < src.w; x++) {
+        const si = (y * src.w + x) * 4;
+        const a = src.data[si + 3] / 255;
+        const o = ((y0 + y) * w + x0 + x) * 4;
+        for (let c = 0; c < 3; c++) out[o + c] = Math.round(src.data[si + c] * a + out[o + c] * (1 - a));
+      }
+    }
+  };
+  blit(L, margin, margin);
+  blit(R, margin + lw + gutter, margin);
+  const fill = (x0, x1, y0, y1, v) => {
+    for (let y = y0; y < y1; y++)
+      for (let x = x0; x < x1; x++) {
+        const o = (y * w + x) * 4;
+        out[o] = v;
+        out[o + 1] = v;
+        out[o + 2] = v;
+      }
+  };
+  fill(margin, margin + lw, margin + height + 6, margin + height + 6 + band, 40);
+  fill(margin + lw + gutter, margin + lw + gutter + rw, margin + height + 6, margin + height + 6 + band, 200);
+  return { w, h, data: out };
+}
+async function judgeKit(kitPath, manifestPath, outDir) {
+  const kit = JSON.parse(await readFile6(kitPath, "utf8"));
+  const manifest = JSON.parse(await readFile6(manifestPath, "utf8"));
+  const manifestDir = dirname(resolve4(manifestPath));
+  const kitDir = dirname(resolve4(kitPath));
+  const out = resolve4(outDir ?? join6(kitDir, "judge"));
+  await mkdir5(out, { recursive: true });
+  const sheets = [];
+  const skipped = [];
+  const refCache = /* @__PURE__ */ new Map();
+  const loadRef = async (file) => {
+    if (refCache.has(file)) return refCache.get(file) ?? null;
+    const p = join6(manifestDir, file);
+    const img = existsSync6(p) ? decodePng(new Uint8Array(await readFile6(p))) : null;
+    refCache.set(file, img);
+    return img;
+  };
+  for (const a of kit.assets) {
+    if (!/\.png$/i.test(a.path)) continue;
+    const file = isAbsolute(a.path) && existsSync6(a.path) ? a.path : join6(kitDir, a.path.split("/").pop() ?? a.path);
+    const img = existsSync6(file) ? decodePng(new Uint8Array(await readFile6(file))) : null;
+    if (!img) {
+      skipped.push(`${a.destination ?? a.path}: unreadable`);
+      continue;
+    }
+    const roles = rolesFor({ destination: a.destination, source: a.source, template: a.template, path: a.path });
+    const ref = manifest.assets.find((r) => roles.includes(r.role) && r.genre !== "context");
+    if (!ref) {
+      skipped.push(`${a.destination ?? a.path}: no reference of role ${roles.join("|") || "(none)"}`);
+      continue;
+    }
+    const refImg = await loadRef(ref.file);
+    if (!refImg) {
+      skipped.push(`${a.destination ?? a.path}: reference ${ref.file} unreadable`);
+      continue;
+    }
+    const stem = (a.path.split("/").pop() ?? a.path).replace(/\.png$/i, "");
+    const id = stem.replace(/[^A-Za-z0-9_-]+/g, "-") || a.destination || "asset";
+    const nameA = `${id}--A.png`;
+    const nameB = `${id}--B.png`;
+    await writeFile7(join6(out, nameA), encodePng(composeSheet(img, refImg)));
+    await writeFile7(join6(out, nameB), encodePng(composeSheet(refImg, img)));
+    const rubric = [
+      `# ${id} against ${ref.id} (${ref.file})`,
+      "",
+      `Sheet A: the kit asset LEFT (dark band), the reference RIGHT (light band). Sheet B: the reverse.`,
+      `Judge each sheet on its own, both orders, and write the verdict where the two agree; a disagreement is a tie.`,
+      "",
+      `## The reference`,
+      ref.layout,
+      ...ref.facts ? ["", "```json", JSON.stringify(ref.facts, null, 2), "```"] : [],
+      "",
+      `Rule: ${ref.rule}`,
+      "",
+      "## The rubric",
+      ...RUBRIC.map((r, i) => `${i + 1}. ${r}`),
+      "",
+      "## Verdict",
+      "In judge.json: `win` true when the kit asset is at least as good as the reference on the rules that apply to its genre, false when it is worse, null for a tie; `reasons` names the rules by number.",
+      ""
+    ].join("\n");
+    await writeFile7(join6(out, `${id}.md`), rubric);
+    sheets.push({ asset: id, reference: ref.id, sheetA: nameA, sheetB: nameB, rubric: `${id}.md` });
+  }
+  const verdictFile = join6(out, "judge.json");
+  if (!existsSync6(verdictFile)) {
+    await writeFile7(
+      verdictFile,
+      JSON.stringify(
+        {
+          kit: kitPath,
+          manifest: manifestPath,
+          verdicts: sheets.map((s) => ({ asset: s.asset, reference: s.reference, A: null, B: null, win: null, reasons: [] }))
+        },
+        null,
+        2
+      )
+    );
+  }
+  return { sheets, skipped, outDir: out, verdictFile };
+}
+function winRate(verdicts) {
+  const judged = verdicts.filter((v) => v.win !== null).length;
+  const wins = verdicts.filter((v) => v.win === true).length;
+  return { wins, judged, rate: judged ? wins / judged : null };
+}
+
+// src/plugin/kitPicture.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { readFile as readFile7 } from "fs/promises";
+var execFileP = promisify(execFile);
+var SUBJECT_BAND = { min: 0.6, max: 0.92 };
+var BLANK_INK = 0.12;
+var SEPARATION_L = 8;
+var SHADOW_PRESENT = 6;
+var EDGE_PRESENT = 40;
+var DUPLICATE_BITS2 = 6;
+var HALFSIZE_KEEP = 0.45;
+function apcaContrast(text, bg) {
+  const lum = (c) => {
+    const ch = (v) => Math.pow(v / 255, 2.4);
+    let y = 0.2126729 * ch(c[0]) + 0.7151522 * ch(c[1]) + 0.072175 * ch(c[2]);
+    if (y < 0.022) y += Math.pow(0.022 - y, 1.414);
+    return y;
+  };
+  const yt = lum(text);
+  const yb = lum(bg);
+  if (Math.abs(yb - yt) < 5e-4) return 0;
+  let sapc;
+  if (yb > yt) {
+    sapc = (Math.pow(yb, 0.56) - Math.pow(yt, 0.57)) * 1.14;
+    return sapc < 0.1 ? 0 : (sapc - 0.027) * 100;
+  }
+  sapc = (Math.pow(yb, 0.65) - Math.pow(yt, 0.62)) * 1.14;
+  return sapc > -0.1 ? 0 : -(sapc + 0.027) * 100;
+}
+var pct = (v) => `${Math.round(v * 100)}%`;
+var hexToRgb = (h) => {
+  const m = /^#([0-9a-f]{6})$/i.exec(h.trim());
+  if (!m) return null;
+  const n = parseInt(m[1], 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+};
+function stillFindings(a, img, m) {
+  const out = [];
+  const genre = a.spec?.genre;
+  const bledAll = m.bleed.length === 4;
+  if (a.shot) {
+    const sx = Math.max(0, a.shot.x) * img.w;
+    const sy = Math.max(0, a.shot.y) * img.h;
+    const sw = Math.min(1, a.shot.x + a.shot.w) * img.w - sx;
+    const sh = Math.min(1, a.shot.y + a.shot.h) * img.h - sy;
+    const rect = { x: sx, y: sy, w: Math.max(1, sw), h: Math.max(1, sh) };
+    const ink = inkCoverage(img, rect);
+    if (ink < BLANK_INK) {
+      out.push({
+        code: "blank",
+        severity: "error",
+        asset: a.destination,
+        message: `${pct(ink)} ink inside the shot: the moment shows a wallpaper, an empty canvas or a flat panel`,
+        fixHint: "pick a moment after a gesture landed (--shot-time, or --times step:<id>) and stage the set before recording",
+        bbox: rect
+      });
+    }
+    if (a.shot.w < 0.5 || a.shot.w > 1.2) {
+      out.push({
+        code: "subject",
+        severity: "error",
+        asset: a.destination,
+        message: `the shot is ${pct(a.shot.w)} of the width; a card sits at 60 to 92%, a bleed a little past the edge`,
+        fixHint: "the template layout places the slot; fix its place for this aspect",
+        bbox: rect
+      });
+    }
+    for (const f of textFindings(a, img)) out.push(f);
+    return out;
+  }
+  const subject = m.card ?? { x: 0, y: 0, w: img.w, h: img.h };
+  if (m.ink < BLANK_INK) {
+    out.push({
+      code: "blank",
+      severity: "error",
+      asset: a.destination,
+      message: `${pct(m.ink)} ink inside the ${m.card ? "card" : "frame"}: a wallpaper, an empty canvas or a flat panel, not the product doing something`,
+      fixHint: "pick a moment after a gesture landed (--times step:<id>) and stage the set before recording: real data, a populated state",
+      bbox: subject
+    });
+  }
+  if (genre === "card") {
+    if (bledAll || m.widthPct === null) {
+      out.push({
+        code: "subject",
+        severity: "error",
+        asset: a.destination,
+        message: bledAll ? "the picture fills the frame on all four sides: a crop, not a card on a ground" : "no card found: the frame is one flat tone",
+        fixHint: "present the card in a look (vos deliver reads BRAND.md or --look) or render this destination from a poster template"
+      });
+    } else if (m.widthPct < SUBJECT_BAND.min || m.widthPct > SUBJECT_BAND.max) {
+      out.push({
+        code: "subject",
+        severity: "error",
+        asset: a.destination,
+        message: `the card is ${pct(m.widthPct)} of the width; the references sit at ${pct(SUBJECT_BAND.min)} to ${pct(SUBJECT_BAND.max)}`,
+        fixHint: "the look places the card at 84% (frame.inset); a poster template sets its own placement",
+        bbox: m.card ?? void 0
+      });
+    }
+    if (m.card && !bledAll) {
+      const sep = m.separation ?? 0;
+      const shadow = m.shadow ?? 0;
+      if (sep < SEPARATION_L && shadow < SHADOW_PRESENT && m.edge < EDGE_PRESENT) {
+        out.push({
+          code: "separation",
+          severity: "error",
+          asset: a.destination,
+          message: `the card and the ground are ${sep.toFixed(1)} L* apart with no shadow halo (${shadow.toFixed(1)}) and no drawn edge (${m.edge.toFixed(0)}): the card dissolves into the plate`,
+          fixHint: "a contact shadow (frame.shadowContact) plus a hairline (frame.border with borderColor) makes a light card sit on a light ground; the plate look sets both",
+          bbox: m.card
+        });
+      }
+    }
+  }
+  if (genre === "screenshot" && a.composed && m.card && (m.widthPct ?? 0) < 0.98) {
+    out.push({
+      code: "subject",
+      severity: "error",
+      asset: a.destination,
+      message: `a store screenshot must be the real page full bleed; this one shows a ${pct(m.widthPct ?? 0)} card on a ground`,
+      fixHint: "drop --composed: the screenshot genre renders the page with no chrome and no padding",
+      bbox: m.card
+    });
+  }
+  if (img.w <= 500 && (a.spec?.text === "none" || genre === "card")) {
+    const full = edgeEnergy(img, Math.min(img.w, 400));
+    const half = edgeEnergy(img, Math.min(img.w, 400) >> 1);
+    const keep = full > 0 ? half / full : 1;
+    if (keep < HALFSIZE_KEEP) {
+      out.push({
+        code: "halfsize",
+        severity: "warning",
+        asset: a.destination,
+        message: `at half size the tile keeps ${pct(keep)} of its edges: fine text and thin lines vanish where the store shows it small`,
+        fixHint: "a tile is the subject large and saturated with no text (the store rule); render it from the card-on-gradient template"
+      });
+    }
+  }
+  for (const f of textFindings(a, img)) out.push(f);
+  return out;
+}
+function textFindings(a, img) {
+  const out = [];
+  for (const t of a.text ?? []) {
+    const box = { x: t.x * img.w, y: t.y * img.h, w: t.w * img.w, h: t.h * img.h };
+    const name = t.label ? `"${t.label}"` : "a text box";
+    if (box.x < 0 || box.y < 0 || box.x + box.w > img.w + 0.5 || box.y + box.h > img.h + 0.5) {
+      out.push({
+        code: "sliced",
+        severity: "error",
+        asset: a.destination,
+        message: `${name} crosses the frame edge: cut mid-word`,
+        fixHint: "shorten the line, or let the template recompose (headline lines at 12 to 14% of the height, inside the safe rect)",
+        bbox: box
+      });
+    }
+    const s = a.spec?.safe;
+    if (s) {
+      const sx = s.x * img.w;
+      const sy = s.y * img.h;
+      const sw = s.w * img.w;
+      const sh = s.h * img.h;
+      if (box.x < sx - 0.5 || box.y < sy - 0.5 || box.x + box.w > sx + sw + 0.5 || box.y + box.h > sy + sh + 0.5) {
+        out.push({
+          code: "safe",
+          severity: "warning",
+          asset: a.destination,
+          message: `${name} sits outside the destination's safe rect (${pct(s.w)}x${pct(s.h)} at ${pct(s.x)},${pct(s.y)}): the platform's chrome or crop covers it`,
+          fixHint: "move the text inside the safe rect; the template reads channel-specs safe",
+          bbox: box
+        });
+      }
+    }
+    const rgb2 = t.color ? hexToRgb(t.color) : null;
+    if (rgb2) {
+      const ground = medianColour(img, box);
+      const lc = apcaContrast(rgb2, ground);
+      const floor = t.role === "body" ? 75 : 60;
+      if (lc < floor) {
+        out.push({
+          code: "contrast",
+          severity: "warning",
+          asset: a.destination,
+          message: `${name} reads APCA Lc ${lc.toFixed(0)} on its ground; ${t.role === "body" ? "body" : "a headline"} wants ${floor}`,
+          fixHint: "darken the ink or lighten the ground under the text (BRAND.md ink on bgA/bgB, never on the shot)",
+          bbox: box
+        });
+      }
+    }
+  }
+  if (a.spec?.text === "none" && (a.text?.length ?? 0) > 0) {
+    out.push({
+      code: "safe",
+      severity: "warning",
+      asset: a.destination,
+      message: "this destination wants no text (the picture carries it alone) and the kit put words on it",
+      fixHint: "render the tile from the card-on-gradient template with no headline"
+    });
+  }
+  return out;
+}
+function duplicateFindings(stills) {
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  const comparable = (a, b) => a.genre === "screenshot" || b.genre === "screenshot" ? a.destination === b.destination : true;
+  for (let i = 0; i < stills.length; i++) {
+    if (seen.has(i)) continue;
+    const g = [stills[i]];
+    for (let j = i + 1; j < stills.length; j++) {
+      if (seen.has(j)) continue;
+      if (!comparable(stills[i], stills[j])) continue;
+      if (hammingDistance(stills[i].hash, stills[j].hash) <= DUPLICATE_BITS2) {
+        g.push(stills[j]);
+        seen.add(j);
+      }
+    }
+    if (g.length > 1) groups.push(g);
+  }
+  return groups.map((g) => ({
+    code: "duplicate",
+    severity: g.length >= 3 ? "error" : "warning",
+    asset: g.map((s) => s.destination).join(", "),
+    message: `${g.length} assets share one frame${g[0].time !== null ? ` (${g[0].time.toFixed(2)}s)` : ""}: ${g.map((s) => s.destination).join(", ")}`,
+    fixHint: "a kit is many moments: let deliver pick from the step timeline, or pass --times with one step per still; a poster template composes each card differently from one shot"
+  }));
+}
+async function videoFrame(file, at2, ffmpeg) {
+  try {
+    const { stdout } = await execFileP(
+      ffmpeg,
+      ["-v", "error", "-ss", at2.toFixed(3), "-i", file, "-frames:v", "1", "-f", "image2pipe", "-vcodec", "png", "-"],
+      { encoding: "buffer", maxBuffer: 64 * 1024 * 1024 }
+    );
+    return decodePng(new Uint8Array(stdout));
+  } catch {
+    return null;
+  }
+}
+async function onPath(bin) {
+  try {
+    await execFileP(bin, ["-version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pictureChecks(assets) {
+  const findings = [];
+  const measured = [];
+  const stills = [];
+  let ffmpeg = null;
+  for (const a of assets) {
+    if (/\.png$/i.test(a.file)) {
+      const img = decodePng(new Uint8Array(await readFile7(a.file)));
+      if (!img) {
+        findings.push({
+          code: "unreadable",
+          severity: "info",
+          asset: a.destination,
+          message: `${a.path} is not an 8-bit non-interlaced PNG; the picture checks cannot read it`,
+          fixHint: "render stills through vos deliver or vos frames, which write readable PNGs"
+        });
+        measured.push({ destination: a.destination, measure: null });
+        continue;
+      }
+      const m = measureStill(img);
+      measured.push({ destination: a.destination, measure: m });
+      findings.push(...stillFindings(a, img, m));
+      if (a.spec?.kind !== "video")
+        stills.push({
+          destination: a.destination,
+          hash: m.hash,
+          time: null,
+          genre: a.spec?.genre
+        });
+      continue;
+    }
+    if (/\.(mp4|webm|mov)$/i.test(a.file)) {
+      if (ffmpeg === null) ffmpeg = await onPath("ffmpeg");
+      if (!ffmpeg) {
+        findings.push({
+          code: "firstlast",
+          severity: "info",
+          asset: a.destination,
+          message: "ffmpeg is not on PATH, so the first and last frames were not read",
+          fixHint: "install ffmpeg to have the video checks run"
+        });
+        measured.push({ destination: a.destination, measure: null });
+        continue;
+      }
+      const seconds = a.seconds ?? 0;
+      const first = await videoFrame(a.file, 0, "ffmpeg");
+      const last = await videoFrame(a.file, Math.max(0, seconds - 0.1), "ffmpeg");
+      for (const [name, img] of [
+        ["first", first],
+        ["last", last]
+      ]) {
+        if (!img) continue;
+        const m = measureStill(img);
+        if (name === "first") measured.push({ destination: a.destination, measure: m });
+        const subject = m.card ?? { x: 0, y: 0, w: img.w, h: img.h };
+        const ink = inkCoverage(img, subject);
+        if (ink < BLANK_INK) {
+          findings.push({
+            code: "firstlast",
+            severity: "error",
+            asset: a.destination,
+            message: `the ${name} frame is ${pct(ink)} ink: a ${name === "first" ? "cold open on nothing" : "clip that ends on nothing"}`,
+            fixHint: name === "first" ? "open on the product (trim the head, or an entrance over a populated frame)" : "end on a resolved state or an end card (the last frame is the poster)"
+          });
+        }
+        if (m.bleed.length === 4 && a.spec?.genre !== "screenshot") {
+          findings.push({
+            code: "firstlast",
+            severity: "warning",
+            asset: a.destination,
+            message: `the ${name} frame fills the frame on all four sides: no ground, no room`,
+            fixHint: "present the cut in a look (vos deliver reads BRAND.md or --look)"
+          });
+        }
+      }
+      continue;
+    }
+  }
+  findings.push(...duplicateFindings(stills));
+  const order = { error: 0, warning: 1, info: 2 };
+  findings.sort((a, b) => order[a.severity] - order[b.severity]);
+  return { findings, measured };
+}
+function formatFinding(f) {
+  const where = f.bbox ? ` @ ${Math.round(f.bbox.x)},${Math.round(f.bbox.y)} ${Math.round(f.bbox.w)}x${Math.round(f.bbox.h)}` : "";
+  return `${f.severity} ${f.code} ${f.asset}${where}: ${f.message}
+    fix: ${f.fixHint}`;
+}
+
+// src/plugin/validateKit.ts
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile8, stat as stat2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join as join7 } from "path";
+import { DESTINATIONS as DESTINATIONS3 } from "@vosjs/studio-core";
+var PNG_SIG2 = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
 function pngDimensions(bytes) {
-  if (bytes.length < 24 || !bytes.subarray(0, 8).equals(PNG_SIG)) return null;
+  if (bytes.length < 24 || !bytes.subarray(0, 8).equals(PNG_SIG2)) return null;
   if (bytes.toString("ascii", 12, 16) !== "IHDR") return null;
   return { w: bytes.readUInt32BE(16), h: bytes.readUInt32BE(20) };
 }
 function sniffImage(bytes) {
-  if (bytes.subarray(0, 8).equals(PNG_SIG)) return "png";
+  if (bytes.subarray(0, 8).equals(PNG_SIG2)) return "png";
   if (bytes.length >= 12 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP")
     return "webp";
   if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216) return "jpeg";
@@ -3036,7 +5208,7 @@ async function probeVideo(path) {
   const MB = await import("mediabunny");
   const input = new MB.Input({
     formats: MB.ALL_FORMATS,
-    source: new MB.BufferSource(new Uint8Array(await readFile5(path)))
+    source: new MB.BufferSource(new Uint8Array(await readFile8(path)))
   });
   try {
     const track = await input.getPrimaryVideoTrack();
@@ -3048,16 +5220,16 @@ async function probeVideo(path) {
   }
 }
 var specById = new Map(
-  DESTINATIONS2.map((d) => [d.id, d])
+  DESTINATIONS3.map((d) => [d.id, d])
 );
 var near = (a, b, tol) => Math.abs(a - b) <= tol;
-async function validateKit(kitPath) {
+async function validateKit(kitPath, opts = {}) {
   const problems = [];
   const warnings = [];
   const measured = [];
   let kit;
   try {
-    kit = JSON.parse(await readFile5(kitPath, "utf8"));
+    kit = JSON.parse(await readFile8(kitPath, "utf8"));
   } catch (e) {
     return {
       valid: false,
@@ -3074,13 +5246,14 @@ async function validateKit(kitPath) {
       measured
     };
   }
-  const base = dirname(kitPath);
+  const base = dirname2(kitPath);
   const resolvePath = (p) => {
-    if (isAbsolute(p) && existsSync5(p)) return p;
-    const beside = join6(base, p.split("/").pop() ?? p);
+    if (isAbsolute2(p) && existsSync7(p)) return p;
+    const beside = join7(base, p.split("/").pop() ?? p);
     return beside;
   };
   const perDestination = /* @__PURE__ */ new Map();
+  const pictureAssets = [];
   for (const a of kit.assets) {
     const id = a.destination ?? `${a.channel}-${a.asset}`;
     const label = `${a.channel} ${a.asset}`;
@@ -3102,7 +5275,7 @@ async function validateKit(kitPath) {
     let h = null;
     let seconds = null;
     if (/\.(png|jpe?g|webp)$/i.test(file)) {
-      const head = Buffer.from(await readFile5(file));
+      const head = Buffer.from(await readFile8(file));
       const kind = sniffImage(head);
       if (file.toLowerCase().endsWith(".png") && kind !== "png")
         problems.push(
@@ -3147,6 +5320,16 @@ async function validateKit(kitPath) {
       );
     }
     measured.push({ destination: id, path: a.path, w, h, bytes, seconds });
+    pictureAssets.push({
+      destination: id,
+      path: a.path,
+      file,
+      spec,
+      text: a.text,
+      seconds,
+      composed: a.composed,
+      shot: a.source === "poster" ? a.shot : void 0
+    });
     if (!spec) {
       if (a.channel !== "demo")
         warnings.push(
@@ -3184,13 +5367,25 @@ async function validateKit(kitPath) {
         `${spec.channel} ${spec.asset}: spec wants ${spec.count.min}-${spec.count.max}, the kit has ${n}`
       );
   }
-  return { valid: problems.length === 0, problems, warnings, measured };
+  if (!opts.picture) {
+    return { valid: problems.length === 0, problems, warnings, measured };
+  }
+  const picture = await pictureChecks(pictureAssets);
+  const pictureErrors = picture.findings.filter((f) => f.severity === "error");
+  return {
+    valid: problems.length === 0 && pictureErrors.length === 0,
+    problems,
+    warnings,
+    measured,
+    picture: picture.findings,
+    pictureMeasured: picture.measured
+  };
 }
 
 // src/plugin/platform.ts
 import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function platformOrigin(flags = {}) {
   const legacyEnv = process.env.VOS_API_BASE?.trim();
   const raw = flags.origin ?? flags.api ?? process.env.VOS_ORIGIN?.trim() ?? legacyEnv ?? "https://vos.so";
@@ -3223,7 +5418,7 @@ function parseVosId(input) {
 function deriveSlug(title) {
   return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/, "") || "remix";
 }
-var CREDENTIALS_PATH = join7(homedir(), ".config", "vos", "credentials");
+var CREDENTIALS_PATH = join8(homedir(), ".config", "vos", "credentials");
 function resolveCredential(explicit) {
   const flag = explicit?.trim();
   if (flag) return flag;
@@ -3246,7 +5441,7 @@ function requireCredential(explicit) {
   return key;
 }
 function writeCredential(key) {
-  mkdirSync(join7(homedir(), ".config", "vos"), { recursive: true, mode: 448 });
+  mkdirSync(join8(homedir(), ".config", "vos"), { recursive: true, mode: 448 });
   writeFileSync(CREDENTIALS_PATH, `${key.trim()}
 `, { mode: 384 });
   return CREDENTIALS_PATH;
@@ -3290,7 +5485,7 @@ function readJsonFile(file) {
   }
 }
 function readSyncState(dir) {
-  const own = readJsonFile(join7(dir, SYNC_STATE_NAME));
+  const own = readJsonFile(join8(dir, SYNC_STATE_NAME));
   if (own && typeof own.vosId === "string") {
     return {
       vosId: own.vosId,
@@ -3301,7 +5496,7 @@ function readSyncState(dir) {
       ...typeof own.remixOfId === "string" ? { remixOfId: own.remixOfId } : {}
     };
   }
-  const push = readJsonFile(join7(dir, "push.json"));
+  const push = readJsonFile(join8(dir, "push.json"));
   if (push && typeof push.vosId === "string") {
     return {
       vosId: push.vosId,
@@ -3309,7 +5504,7 @@ function readSyncState(dir) {
       ...typeof push.pushedAt === "string" ? { pushedAt: push.pushedAt } : {}
     };
   }
-  const meta = readJsonFile(join7(dir, "meta.json"));
+  const meta = readJsonFile(join8(dir, "meta.json"));
   if (meta && typeof meta.id === "string") {
     return {
       vosId: meta.id,
@@ -3327,7 +5522,7 @@ function writeSyncState(dir, patch) {
     ...patch
   };
   writeFileSync(
-    join7(dir, SYNC_STATE_NAME),
+    join8(dir, SYNC_STATE_NAME),
     `${JSON.stringify(merged, null, 2)}
 `
   );
@@ -3348,7 +5543,7 @@ function formatChanges(changes) {
 
 // src/plugin/recorder.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/plugin/recordingCap.ts
 var HOSTED_RECORDING_CAP_SECONDS = 30 * 60;
@@ -3436,7 +5631,7 @@ async function recordTake(browser, url, actions, paths, log, opts = {}) {
   cdp.on("Page.screencastFrame", (ev) => {
     const tsMs = ev.metadata.timestamp ? ev.metadata.timestamp * 1e3 : Date.now();
     const file = `frame-${String(frameIdx++).padStart(5, "0")}.jpg`;
-    writeFileSync2(join8(paths.framesDir, file), Buffer.from(ev.data, "base64"));
+    writeFileSync2(join9(paths.framesDir, file), Buffer.from(ev.data, "base64"));
     frames.push({ file, tMs: Math.max(0, Math.round(tsMs - t0)) });
     cdp.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => {
     });
@@ -3659,7 +5854,7 @@ async function recordTake(browser, url, actions, paths, log, opts = {}) {
   await sleep(200);
   const pageTitle = await page.title().catch(() => "");
   await context.close();
-  const firstFrame = frames[0] ? jpegDims(readFileSync3(join8(paths.framesDir, frames[0].file))) : null;
+  const firstFrame = frames[0] ? jpegDims(readFileSync3(join9(paths.framesDir, frames[0].file))) : null;
   const meta = {
     dpr: 1,
     zoom: 1,
@@ -3767,9 +5962,9 @@ async function encodeRecording(browser, takeDir, onProgress) {
 }
 
 // src/plugin/plan.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile6 } from "fs/promises";
-import { join as join9 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
+import { join as join10 } from "path";
 import {
   DEFAULT_FRAME_STYLE,
   STYLE_FIELDS,
@@ -3962,10 +6157,10 @@ function retimeCut(prev, newSteps, newDurationMs) {
 // src/plugin/plan.ts
 var overlaps = (a, b) => a.in < b.out && b.in < a.out;
 async function readDigestActivity(dir) {
-  const file = join9(dir, "digest", "digest.json");
-  if (!existsSync6(file)) return null;
+  const file = join10(dir, "digest", "digest.json");
+  if (!existsSync8(file)) return null;
   try {
-    const d = JSON.parse(await readFile6(file, "utf8"));
+    const d = JSON.parse(await readFile9(file, "utf8"));
     return Array.isArray(d.activity) && d.activity.every((v) => typeof v === "number") ? d.activity : null;
   } catch {
     return null;
@@ -4078,16 +6273,16 @@ async function planTake(dir, opts = {}) {
 
 // src/plugin/sync.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync8 } from "fs";
-import { readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { readFile as readFile10 } from "fs/promises";
 import { createInterface } from "readline/promises";
-import { basename, join as join12 } from "path";
+import { basename, join as join13 } from "path";
 import { lowerToComposition as lowerToComposition3, migrateHostedDoc as migrateHostedDoc2 } from "@vosjs/studio-core";
 
 // src/plugin/media.ts
-import { createWriteStream, existsSync as existsSync7 } from "fs";
-import { writeFile as writeFile7 } from "fs/promises";
-import { join as join10 } from "path";
+import { createWriteStream, existsSync as existsSync9 } from "fs";
+import { writeFile as writeFile8 } from "fs/promises";
+import { join as join11 } from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 var MIC_NAME = "mic.webm";
@@ -4108,8 +6303,8 @@ async function pullMedia(ctx, dir, doc, log) {
     const url = doc.source[key];
     const assetId = assetIdOf(url);
     if (!assetId) continue;
-    const target = join10(dir, file);
-    if (existsSync7(target)) {
+    const target = join11(dir, file);
+    if (existsSync9(target)) {
       result.kept.push(file);
     } else {
       const abs = /^https?:/.test(url) ? url : `${ctx.origin}${url}`;
@@ -4131,17 +6326,17 @@ async function pullMedia(ctx, dir, doc, log) {
     }
     doc.source[key] = file;
   }
-  const metaPath = join10(dir, "meta.json");
-  if (!existsSync7(metaPath)) await writeJson(metaPath, doc.source.meta, true);
-  const cursorPath = join10(dir, "cursor.json");
-  if (!existsSync7(cursorPath)) await writeJson(cursorPath, doc.source.cursor);
-  await writeFile7(join10(dir, "doc.json"), JSON.stringify(doc, null, 2));
+  const metaPath = join11(dir, "meta.json");
+  if (!existsSync9(metaPath)) await writeJson(metaPath, doc.source.meta, true);
+  const cursorPath = join11(dir, "cursor.json");
+  if (!existsSync9(cursorPath)) await writeJson(cursorPath, doc.source.cursor);
+  await writeFile8(join11(dir, "doc.json"), JSON.stringify(doc, null, 2));
   return result;
 }
 
 // src/plugin/folder.ts
-import { mkdir as mkdir5, writeFile as writeFile8 } from "fs/promises";
-import { join as join11 } from "path";
+import { mkdir as mkdir6, writeFile as writeFile9 } from "fs/promises";
+import { join as join12 } from "path";
 import { recipeHints } from "@vosjs/shared/frontmatter";
 import { migrateHostedDoc } from "@vosjs/studio-core";
 var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["json", "help", "media"]);
@@ -4317,25 +6512,25 @@ async function cmdPull(argv) {
     throw new Error(apiError(`pull folder ${folder.slug}`, res));
   const payload = res.body;
   const out = strFlag(flags, "out") ?? folder.slug;
-  await mkdir5(join11(out, "recipes"), { recursive: true });
+  await mkdir6(join12(out, "recipes"), { recursive: true });
   const lines = [];
   const recipes = [];
   for (const rec of payload.recipes) {
-    const path = join11(out, "recipes", safeName(rec.filename));
-    await writeFile8(path, rec.body ?? "");
+    const path = join12(out, "recipes", safeName(rec.filename));
+    await writeFile9(path, rec.body ?? "");
     recipes.push({ path, line: recipeLine(rec.filename, rec.body ?? "") });
   }
   for (const rec of payload.inheritedRecipes) {
     const from = safeName(rec.folderSlug ?? "inherited");
-    await mkdir5(join11(out, "recipes", "_inherited", from), { recursive: true });
-    const path = join11(
+    await mkdir6(join12(out, "recipes", "_inherited", from), { recursive: true });
+    const path = join12(
       out,
       "recipes",
       "_inherited",
       from,
       safeName(rec.filename)
     );
-    await writeFile8(path, rec.body ?? "");
+    await writeFile9(path, rec.body ?? "");
     recipes.push({
       path,
       line: `${recipeLine(rec.filename, rec.body ?? "")}  [inherited from ${rec.folderName ?? from}]`
@@ -4343,15 +6538,15 @@ async function cmdPull(argv) {
   }
   const members = [];
   for (const v of payload.voses) {
-    const dir = join11(out, "members", safeName(v.slug || v.title || v.id));
-    await mkdir5(dir, { recursive: true });
+    const dir = join12(out, "members", safeName(v.slug || v.title || v.id));
+    await mkdir6(dir, { recursive: true });
     const cfg = await apiJson(origin, `/api/vos/${v.id}/config`, { key });
     if (cfg.status !== 200) {
       lines.push(`skipped ${v.title}: ${apiError("fetch config", cfg)}`);
       continue;
     }
-    await writeFile8(
-      join11(dir, "config.json"),
+    await writeFile9(
+      join12(dir, "config.json"),
       JSON.stringify(cfg.body.config, null, 2)
     );
     let take = false;
@@ -4362,8 +6557,8 @@ async function cmdPull(argv) {
         { key }
       );
       if (doc.status === 200) {
-        await writeFile8(
-          join11(dir, "doc.json"),
+        await writeFile9(
+          join12(dir, "doc.json"),
           JSON.stringify(doc.body, null, 2)
         );
         take = true;
@@ -4480,7 +6675,7 @@ async function pushTake(dir, flags, r) {
     throw new Error(`doc.json fails lint:
   ${lint.problems.join("\n  ")}`);
   }
-  if (!existsSync8(take.paths.recording)) {
+  if (!existsSync10(take.paths.recording)) {
     throw new Error("no recording.webm in this take");
   }
   const ctx = apiContext(flags);
@@ -4512,7 +6707,7 @@ async function pushTake(dir, flags, r) {
       throw new Error("push cancelled");
     }
   }
-  const bytes = await readFile7(take.paths.recording);
+  const bytes = await readFile10(take.paths.recording);
   const hash = createHash("sha256").update(bytes).digest("hex");
   r.log(`uploading recording (${Math.round(bytes.length / 1024)} kB)\u2026`);
   const upload = await api(ctx, "/assets/recording", {
@@ -4635,6 +6830,7 @@ async function pullTake(dir, flags, r) {
   if (!vosId) {
     throw new Error("this take was never pushed \u2014 pass --vos <id> to link it");
   }
+  const base = flags.since ?? state?.versionId ?? null;
   const meta = await api(ctx, `/vos/${vosId}`);
   if (meta.status !== 200) {
     throw new Error(
@@ -4645,12 +6841,26 @@ async function pullTake(dir, flags, r) {
     meta.json.vos?.currentVersionId ?? ""
   );
   if (!head) throw new Error("this vos has no versions");
-  if (state && state.versionId === head) {
-    r.log("up to date \u2014 HEAD is your last push");
+  if (base === head) {
+    r.log(
+      flags.since ? "up to date \u2014 --since names the head" : "up to date \u2014 HEAD is your last push"
+    );
+    if (flags.check) {
+      return {
+        vosId,
+        versionId: head,
+        versionNumber: null,
+        changed: false,
+        checked: true,
+        behind: 0,
+        changes: [],
+        protected: []
+      };
+    }
     let media2;
-    if (flags.media && existsSync8(join12(dir, "doc.json"))) {
+    if (flags.media && existsSync10(join13(dir, "doc.json"))) {
       const local = JSON.parse(
-        await readFile7(join12(dir, "doc.json"), "utf8")
+        await readFile10(join13(dir, "doc.json"), "utf8")
       );
       media2 = await pullMedia(ctx, dir, local, r.log);
     }
@@ -4662,15 +6872,45 @@ async function pullTake(dir, flags, r) {
       media: media2
     };
   }
-  if (state?.versionId) {
+  let walked = null;
+  if (base) {
     const changes = await api(
       ctx,
-      `/vos/${vosId}/changes?since=${state.versionId}`
+      `/vos/${vosId}/changes?since=${encodeURIComponent(base)}`
     );
     if (changes.status === 200) {
-      r.log("changes since your last push:");
+      r.log(
+        flags.since ? `changes since ${base.slice(0, 8)}\u2026:` : "changes since your last push:"
+      );
       printChanges(r, changes.json.changes, changes.json.protected);
+      walked = {
+        changes: Array.isArray(changes.json.changes) ? changes.json.changes : [],
+        protected: Array.isArray(changes.json.protected) ? changes.json.protected : []
+      };
+      if (changes.json.truncated === true) {
+        r.log("walk truncated \u2014 more versions exist; pull again after syncing");
+      }
+    } else {
+      r.log(
+        `changelog unavailable (${changes.status}) \u2014 the head is v?; pass --since <versionId> you can read, or pull to sync`
+      );
     }
+  } else {
+    r.log(
+      "no base to compare from (this take was linked with --vos) \u2014 pass --since <versionId> for the changelog"
+    );
+  }
+  if (flags.check) {
+    return {
+      vosId,
+      versionId: head,
+      versionNumber: null,
+      changed: false,
+      checked: true,
+      behind: walked ? walked.changes.length : null,
+      changes: walked?.changes ?? [],
+      protected: walked?.protected ?? []
+    };
   }
   const docRes = await api(ctx, `/vos/${vosId}/versions/${head}/doc`);
   if (docRes.status !== 200) {
@@ -4680,10 +6920,10 @@ async function pullTake(dir, flags, r) {
   }
   const hostedDoc = migrateHostedDoc2(docRes.json);
   const doc = hostedDoc;
-  if (existsSync8(join12(dir, RECORDING_NAME))) {
+  if (existsSync10(join13(dir, RECORDING_NAME))) {
     doc.source.videoKey = RECORDING_NAME;
   }
-  await writeJson(join12(dir, "doc.json"), doc, true);
+  await writeJson(join13(dir, "doc.json"), doc, true);
   const media = flags.media ? await pullMedia(ctx, dir, doc, r.log) : void 0;
   const versions = await api(ctx, `/vos/${vosId}/versions`);
   const headRow = (versions.json.versions ?? []).find((v) => v.id === head);
@@ -4702,10 +6942,10 @@ async function pullTake(dir, flags, r) {
 }
 
 // src/plugin/program.ts
-import { existsSync as existsSync9, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { mkdir as mkdir6, readFile as readFile8, writeFile as writeFile9 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import { mkdir as mkdir7, readFile as readFile11, writeFile as writeFile10 } from "fs/promises";
 import { createInterface as createInterface2 } from "readline/promises";
-import { basename as basename2, dirname as dirname2, join as join13 } from "path";
+import { basename as basename2, dirname as dirname3, join as join14 } from "path";
 import {
   CURRENT_CONFIG_VERSION,
   migrateConfig,
@@ -4875,8 +7115,8 @@ function preflightConfig(parsed) {
 }
 function resolveConfigPath(target) {
   if (target.endsWith(".json")) return target;
-  const inDir = join13(target, "config.json");
-  if (existsSync9(inDir)) return inDir;
+  const inDir = join14(target, "config.json");
+  if (existsSync11(inDir)) return inDir;
   throw new UsageError(
     `${target} has no config.json (and is not a take \u2014 no doc.json)`
   );
@@ -4902,9 +7142,9 @@ async function cmdFetch(argv) {
     throw new Error(apiError(`fetch config for ${vosId}`, cfg));
   const slug = typeof vosMeta.slug === "string" && vosMeta.slug ? vosMeta.slug : vosId;
   const out = strFlag(flags, "out") ?? slug;
-  await mkdir6(out, { recursive: true });
-  await writeFile9(
-    join13(out, "config.json"),
+  await mkdir7(out, { recursive: true });
+  await writeFile10(
+    join14(out, "config.json"),
     JSON.stringify(cfg.body.config, null, 2)
   );
   const title = typeof vosMeta.title === "string" ? vosMeta.title : "";
@@ -4929,12 +7169,12 @@ async function cmdFetch(argv) {
       const hosted = migrateHostedDoc3(doc.body);
       const { config: own } = await writeProgramDoc(out, hosted);
       if (own) {
-        await writeFile9(join13(out, "config.json"), JSON.stringify(own, null, 2));
+        await writeFile10(join14(out, "config.json"), JSON.stringify(own, null, 2));
       }
     } else if (doc.status === 200) {
       take = true;
       const hosted = migrateHostedDoc3(doc.body);
-      await writeFile9(join13(out, "doc.json"), JSON.stringify(hosted, null, 2));
+      await writeFile10(join14(out, "doc.json"), JSON.stringify(hosted, null, 2));
       if (flags.media === true) {
         const media = await pullMedia({ origin, key }, out, hosted, r.log);
         mediaLine = media.downloaded.length ? ` + ${media.downloaded.map((m) => m.file).join(", ")}` : "";
@@ -5045,8 +7285,8 @@ async function cmdPushProgram(argv) {
     origin: strFlag(flags, "origin"),
     api: strFlag(flags, "api")
   });
-  const dir = dirname2(source);
-  const parsed = JSON.parse(await readFile8(source, "utf8"));
+  const dir = dirname3(source);
+  const parsed = JSON.parse(await readFile11(source, "utf8"));
   const pre = preflightConfig(parsed);
   if (!pre.ok || !pre.config) {
     for (const issue of pre.issues) r.log(`error ${issue}`);
@@ -5215,7 +7455,7 @@ Iterate with: vos push ${source} --vos ${created.id}`
 async function cmdPullProgram(argv) {
   const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS2);
   const target = positionals[0] ?? ".";
-  const dir = target.endsWith(".json") ? dirname2(target) : target;
+  const dir = target.endsWith(".json") ? dirname3(target) : target;
   const r = createReporter(flags.json === true);
   const origin = platformOrigin({
     origin: strFlag(flags, "origin"),
@@ -5279,10 +7519,10 @@ async function cmdPullProgram(argv) {
   const cfg = await apiJson(origin, `/api/vos/${vosId}/config`, { key });
   if (cfg.status !== 200)
     throw new Error(apiError(`fetch head config for ${vosId}`, cfg));
-  const configPath = join13(dir, "config.json");
+  const configPath = join14(dir, "config.json");
   let backedUp = false;
-  if (existsSync9(configPath)) {
-    await writeFile9(join13(dir, "config.backup.json"), await readFile8(configPath));
+  if (existsSync11(configPath)) {
+    await writeFile10(join14(dir, "config.backup.json"), await readFile11(configPath));
     backedUp = true;
   }
   let headConfig = cfg.body.config;
@@ -5301,7 +7541,7 @@ async function cmdPullProgram(argv) {
       if (own) headConfig = own;
     }
   }
-  await writeFile9(configPath, JSON.stringify(headConfig, null, 2));
+  await writeFile10(configPath, JSON.stringify(headConfig, null, 2));
   writeSyncState(dir, {
     vosId,
     versionId: typeof head.id === "string" ? head.id : since
@@ -5315,7 +7555,7 @@ async function cmdPullProgram(argv) {
       protected: protectedIds,
       changes,
       out: configPath,
-      backup: backedUp ? join13(dir, "config.backup.json") : null
+      backup: backedUp ? join14(dir, "config.backup.json") : null
     },
     `Pulled ${changes.length} version${changes.length === 1 ? "" : "s"} \u2192 ${configPath}` + (backedUp ? ` (previous copy: config.backup.json)` : "") + `
 Re-apply your edit on the new head, then: vos push ${configPath} --vos ${vosId}`
@@ -5369,24 +7609,12 @@ async function storeKey(key, origin, r) {
   return EXIT_OK;
 }
 function isTakeDir(target) {
-  try {
-    if (!statSync2(target).isDirectory()) return false;
-    const docPath = join13(target, "doc.json");
-    if (!existsSync9(docPath)) return false;
-    try {
-      const doc = JSON.parse(readFileSync4(docPath, "utf8"));
-      return typeof doc === "object" && doc !== null && "source" in doc;
-    } catch {
-      return true;
-    }
-  } catch {
-    return false;
-  }
+  return directoryKind(target) === "take";
 }
 async function readProgramDoc(dir, config) {
-  const docPath = join13(dir, "doc.json");
-  if (!existsSync9(docPath)) return null;
-  const parsed = JSON.parse(await readFile8(docPath, "utf8"));
+  const docPath = join14(dir, "doc.json");
+  if (!existsSync11(docPath)) return null;
+  const parsed = JSON.parse(await readFile11(docPath, "utf8"));
   if (typeof parsed !== "object" || parsed === null || "source" in parsed)
     return null;
   const raw = parsed;
@@ -5397,14 +7625,14 @@ async function writeProgramDoc(dir, hosted) {
   const program = hosted.program && typeof hosted.program === "object" ? hosted.program : {};
   const { config, ...rest } = program;
   const onDisk = { ...hosted, program: rest };
-  await writeFile9(join13(dir, "doc.json"), JSON.stringify(onDisk, null, 2));
+  await writeFile10(join14(dir, "doc.json"), JSON.stringify(onDisk, null, 2));
   return {
     config: config && typeof config === "object" ? config : null
   };
 }
 
 // src/plugin/asset.ts
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { basename as basename3, extname as extname2 } from "path";
 var BOOLEAN_FLAGS3 = /* @__PURE__ */ new Set(["json", "help"]);
 var MIME_BY_EXT = {
@@ -5458,7 +7686,7 @@ async function cmdPush(argv) {
   for (const file of positionals) {
     const name = basename3(file);
     const mime = MIME_BY_EXT[extname2(name).toLowerCase()] ?? "application/octet-stream";
-    const body = readFileSync5(file);
+    const body = readFileSync4(file);
     const form = new FormData();
     form.set("file", new Blob([body], { type: mime }), name);
     if (folder) form.set("folderId", folder.id);
@@ -5512,7 +7740,7 @@ async function cmdAsset(argv) {
 }
 
 // src/plugin/recipe.ts
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { basename as basename4 } from "path";
 var BOOLEAN_FLAGS4 = /* @__PURE__ */ new Set(["json", "help"]);
 var USAGE = "vos recipe push <file.md> (--folder <folderId|slug> | --asset <assetId>)";
@@ -5532,7 +7760,7 @@ async function cmdPush2(argv) {
     throw new UsageError(USAGE);
   }
   const filename = recipeFilename(file);
-  const body = readFileSync6(file);
+  const body = readFileSync5(file);
   const r = createReporter(flags.json === true);
   const origin = platformOrigin({
     origin: strFlag(flags, "origin"),
@@ -5604,9 +7832,10 @@ async function cmdRecipe(argv) {
 }
 
 // src/plugin/brand.ts
-import { writeFile as writeFile10 } from "fs/promises";
-import { resolve as resolve4 } from "path";
-import { parseFrontmatter } from "@vosjs/shared/frontmatter";
+import { writeFile as writeFile11 } from "fs/promises";
+import { resolve as resolve5 } 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;
 function extractHexes(text) {
   const out = [];
@@ -5627,13 +7856,13 @@ function rgbToHex(raw) {
   if (!m) return normalizeHex(raw);
   const alpha = m[4];
   if (alpha !== void 0 && Number(alpha) === 0) return null;
-  const hex = (n) => Number(n).toString(16).padStart(2, "0");
-  return `#${hex(m[1])}${hex(m[2])}${hex(m[3])}`;
+  const hex2 = (n) => Number(n).toString(16).padStart(2, "0");
+  return `#${hex2(m[1])}${hex2(m[2])}${hex2(m[3])}`;
 }
-function hsl(hex) {
-  const r = parseInt(hex.slice(1, 3), 16) / 255;
-  const g = parseInt(hex.slice(3, 5), 16) / 255;
-  const b = parseInt(hex.slice(5, 7), 16) / 255;
+function hsl(hex2) {
+  const r = parseInt(hex2.slice(1, 3), 16) / 255;
+  const g = parseInt(hex2.slice(3, 5), 16) / 255;
+  const b = parseInt(hex2.slice(5, 7), 16) / 255;
   const max = Math.max(r, g, b);
   const min = Math.min(r, g, b);
   const l = (max + min) / 2;
@@ -5648,12 +7877,12 @@ function hsl(hex) {
   }
   return { h, s, l };
 }
-function isSaturated(hex) {
-  const { s, l } = hsl(hex);
+function isSaturated(hex2) {
+  const { s, l } = hsl(hex2);
   return s >= 0.25 && l > 0.12 && l < 0.88;
 }
-var isLight = (hex) => hsl(hex).l >= 0.5;
-function mixHex(a, b, t) {
+var isLight = (hex2) => hsl(hex2).l >= 0.5;
+function mixHex2(a, b, t) {
   const ch = (i) => Math.round(
     parseInt(a.slice(i, i + 2), 16) * (1 - t) + parseInt(b.slice(i, i + 2), 16) * t
   ).toString(16).padStart(2, "0");
@@ -5679,7 +7908,7 @@ var FONT_HINT_RE = /\b(?:[Uu]se|[Uu]ses|[Ss]et in)\s+([A-Z][A-Za-z0-9]+(?:\s+[A-
 var FONT_FAMILY_RE = /font-family\s*:\s*["']?([^;"',\n]+)/gi;
 var LOGO_URL_RE = /https?:\/\/[^\s)"'<>]+?(?:logo|wordmark|mark|brand|icon)[^\s)"'<>]*?\.(?:svg|png|webp)/gi;
 function parseDesignMd(text) {
-  const fm = parseFrontmatter(text);
+  const fm = parseFrontmatter2(text);
   const fonts = [];
   for (const m of text.matchAll(FONT_HINT_RE)) {
     const f = m[1].trim();
@@ -5790,7 +8019,7 @@ function composeBrand(input) {
   p.bgA = `the body's background`;
   const surfaceHexes = w.surfaces.map(rgbToHex).filter((h) => h !== null && h !== bgA);
   const neutralSurface = mostCommon(surfaceHexes.filter((h) => !isSaturated(h)));
-  const bgB = neutralSurface ?? mixHex(bgA, isLight(bgA) ? "#000000" : "#ffffff", 0.04);
+  const bgB = neutralSurface ?? mixHex2(bgA, isLight(bgA) ? "#000000" : "#ffffff", 0.04);
   p.bgB = neutralSurface ? `the most common section / card ground` : `no distinct surface found; bgA stepped 4% toward ${isLight(bgA) ? "black" : "white"}`;
   const accentHexes = w.accents.map(rgbToHex).filter((h) => h !== null && isSaturated(h));
   const themeHex = w.themeColor ? rgbToHex(w.themeColor) : null;
@@ -5800,7 +8029,7 @@ function composeBrand(input) {
   const inkHex = rgbToHex(w.h1?.color ?? w.body.color) ?? (isLight(bgA) ? "#111111" : "#f5f5f5");
   if (!accent) accent = inkHex;
   p.accent = accentHexes.length ? `the saturated colour buttons and links agree on` : themeHex && isSaturated(themeHex) ? `the theme-color meta` : design?.hexes.find(isSaturated) ? `a hex quoted in design.md` : `no saturated colour on the page; the ink stands in`;
-  const bgC = mixHex(bgA, accent, 0.14);
+  const bgC = mixHex2(bgA, accent, 0.14);
   p.bgC = `bgA tinted 14% toward the accent (a highlight ground)`;
   p.ink = w.h1 ? `the h1's colour` : `the body's colour`;
   const fontDisplay = design?.fonts[0] ?? (w.h1 ? firstFamily(w.h1.fontFamily) : firstFamily(w.body.fontFamily));
@@ -5831,8 +8060,10 @@ function composeBrand(input) {
     ogImage: w.ogImage,
     wordmark,
     designMd: input.designUrl,
-    llmsTxt: input.llmsUrl
+    llmsTxt: input.llmsUrl,
+    look: lookKindForGround(bgA)
   };
+  p.look = `from the body's ground (${bgA}): a paper site is a plate, a dark site is dark, else the gradient`;
   return { kit, provenance: p, avoid: design?.avoid ?? [] };
 }
 function renderBrandMd(c, claim) {
@@ -5859,6 +8090,7 @@ function renderBrandMd(c, claim) {
     `wordmark: ${q(k.wordmark)}`,
     `designMd: ${q(k.designMd)}`,
     `llmsTxt: ${q(k.llmsTxt)}`,
+    `look: ${q(k.look)}`,
     "---"
   ].join("\n");
   const lines = [
@@ -5909,7 +8141,7 @@ async function cmdBrand(argv) {
     throw new UsageError(`not a URL: ${raw}`);
   }
   const r = createReporter(flags.json === true);
-  const out = resolve4(strFlag(flags, "out") ?? "BRAND.md");
+  const out = resolve5(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`),
@@ -5943,7 +8175,7 @@ async function cmdBrand(argv) {
     composition,
     llms?.claim ?? design?.description ?? null
   );
-  await writeFile10(out, md);
+  await writeFile11(out, md);
   const k = composition.kit;
   r.done(
     {
@@ -5961,8 +8193,8 @@ async function cmdBrand(argv) {
 }
 
 // src/plugin/agentBrowser.ts
-import { writeFile as writeFile11 } from "fs/promises";
-import { resolve as resolve5 } from "path";
+import { writeFile as writeFile12 } from "fs/promises";
+import { resolve as resolve6 } from "path";
 function parseAgentBrowserLog(text) {
   const records = [];
   const problems = [];
@@ -6432,7 +8664,7 @@ async function cmdActions(argv) {
     );
   }
   const r = createReporter(flags.json === true);
-  const out = resolve5(strFlag(flags, "out") ?? "actions.json");
+  const out = resolve6(strFlag(flags, "out") ?? "actions.json");
   const viewportFlag = strFlag(flags, "viewport");
   let viewport;
   if (viewportFlag) {
@@ -6440,8 +8672,8 @@ async function cmdActions(argv) {
     if (!m) throw new UsageError("--viewport expects WxH, e.g. 1280x720");
     viewport = { width: Number(m[1]), height: Number(m[2]) };
   }
-  const { readFile: readFile10 } = await import("fs/promises");
-  const text = await readFile10(resolve5(input), "utf8");
+  const { readFile: readFile13 } = await import("fs/promises");
+  const text = await readFile13(resolve6(input), "utf8");
   const { records, problems } = parseAgentBrowserLog(text);
   for (const p of problems) r.log(`  ${p}`);
   const result = convertAgentBrowser(records, {
@@ -6458,7 +8690,7 @@ async function cmdActions(argv) {
     );
     return EXIT_ERROR;
   }
-  await writeFile11(out, `${JSON.stringify(result.actions, null, 2)}
+  await writeFile12(out, `${JSON.stringify(result.actions, null, 2)}
 `);
   r.done(
     { ok: true, out, url: result.actions.url ?? null, ...summary(result) },
@@ -6481,6 +8713,7 @@ function summary(result) {
 var BOOLEAN_FLAGS5 = /* @__PURE__ */ new Set([
   "json",
   "help",
+  "picture",
   "fresh",
   "reuse",
   "strict",
@@ -6490,7 +8723,9 @@ var BOOLEAN_FLAGS5 = /* @__PURE__ */ new Set([
   "no-frames",
   "media",
   "print",
-  "yes"
+  "yes",
+  "composed",
+  "check"
 ]);
 var MULTI_FLAGS2 = /* @__PURE__ */ new Set(["set", "override"]);
 var HELP = `vos \u2014 record a browser flow, plan effects, render a product video; sync with vos.so
@@ -6501,11 +8736,12 @@ Take pipeline
   vos plan <take> [--fresh] [--reuse [--from <doc.json>]] [--style <doc.json|vosId>] [--background <slug|url|none>] [--json]
   vos render <take> [out.webm] [--width] [--height] [--fps] [--format webm|mp4] [--parallel N] [--range a..b] [--draft] [--frame <kind>] [--background <url|slug>] [--set <path=value>]... [--json]
   vos frames <take> [--times 0,25%,50%,75%,100%] [--frame <t>] [--at-zooms] [--at-moments] [--size WxH] [--out dir] [--background <url|slug>] [--set <path=value>]... [--json]
-  vos deliver <take> --to cws,producthunt,x,linkedin,og,github,youtube (or all) [--poster <config.json|vosId>] [--shot-time <t>] [--poster-time <t>] [--composed] [--set path=value] [--release v2.1] [--out dir] [--times a,b] [--range a..b] [--parallel N] [--json]
+  vos deliver <take> --to cws,producthunt,x,linkedin,og,github,youtube (or all) [--headline "\u2026"] [--kicker "\u2026"] [--launch LAUNCH.md] [--music <slug|mood|none>] [--entrance tilt-in|pull-out|rise|none] [--end-card none] [--captions none] [--clicks none] [--look plate|gradient|dark|none] [--brand BRAND.md] [--poster <split-cover|card-on-gradient|config.json|vosId|none>] [--shot-time <t>] [--poster-time <t>] [--composed] [--set path=value] [--release v2.1] [--out dir] [--times a,b] [--range a..b] [--parallel N] [--json]
   vos digest <take> [--out dir] [--full 960] [--crop 640] [--no-frames] [--transcript <file.json>] [--style <doc.json|vosId>] [--json]
   vos brand <url> [--out BRAND.md] [--json]
   vos open <take> [--studio <url>] [--print]
-  vos validate <actions.json|take> [--json]
+  vos validate <actions.json|take|kit.json> [--picture] [--json]
+  vos judge <kit.json> --against <MANIFEST.json> [--out dir] [--json]
   vos actions from-agent-browser <steps.jsonl> [--out actions.json] [--url <url>] [--viewport WxH] [--json]
 
 Platform (vos.so) \u2014 fetch, edit, push, pull, repeat
@@ -6581,7 +8817,8 @@ actions.json so anchors survive script edits.
 record --strict exits 2 when any selector was skipped, the page never
 reached networkidle, or the take hit --max-duration (the done event lists
 skipped[] and capped either way). --max-duration defaults to the hosted
-recording cap (1800s): the capture stops there and says so in one line.
+recording cap, read live from GET /api/limits (30 min when the origin is
+unreachable): the capture stops there and says so in one line.
 frames captures PNG stills at OUTPUT times (seconds or % of duration);
 --at-zooms adds every zoom span's apex, --at-moments every digest moment \u2014
 the agent's eyes AND exact-size posters/screenshots (--size WxH). render
@@ -6592,13 +8829,47 @@ channel specs (schema/channel-specs.json, verified sizes for the Chrome
 Web Store, Product Hunt, X, LinkedIn, OG, GitHub, YouTube) drive stills at
 exact pixels and video cuts, every artifact is VERIFIED against its spec
 (px, bytes, duration; misses land in skipped[] with the reason), and
-kit.json beside the assets is the manifest. Still times default to the
-zoom apexes (--times overrides); --range cuts every video destination.
---poster <config.json|vosId> is the CARD half: card-genre destinations
-(OG, LinkedIn, X, YouTube thumbnail, the CWS tile + marquee, GitHub
-social preview) render from your poster PROGRAM \u2014 the split-cover family
-\u2014 with this release's shot baked into its image element (id "shot"), PNG
-at exact pixels. --shot-time <t> picks the take moment (OUTPUT seconds;
+kit.json beside the assets is the manifest. Still times come from the
+STORY: every step's end plus a 0.4 s settle (the response, not the
+travel), then the zoom apexes, then an even spread; each candidate is
+read once as the real page, blank ones (a wallpaper, an empty canvas) are
+dropped and two of one frame collapse to one, with every drop said in
+skipped[]. --times overrides with seconds, percents or step:<id>[+offset]
+(the id from actions.json); --range cuts every video destination.
+The LOOK presents the card: card-genre stills with no poster and every
+video cut sit on a ground (a cream plate, the house gradient, a dark plate
+with a light streak) at ~84% of the width with headroom, a soft ambient
+shadow plus a tight contact shadow, and a hairline when card and ground
+are both light; a wide frame runs the card off the bottom. --look picks a
+house look (or none for the pre-look crops); with no flag the BRAND.md
+beside the take (or --brand <file>) decides from its look role or its own
+ground (a paper site is a plate, a dark site is dark), and with no brand
+the house gradient. Screenshot-genre stills never take a look.
+Card-genre destinations (OG, LinkedIn, X, YouTube thumbnail, the CWS
+tile + marquee, GitHub social preview) COMPOSE by default: each renders
+from its destination's poster TEMPLATE (split-cover carries a headline
+column beside the shot; card-on-gradient is the shot alone on a mesh, the
+store's tile rule), filled with BRAND.md's colours and faces and the
+release's words, the shot baked as an object (padded, rounded, shadowed,
+a hairline on a light ground), PNG at exact pixels; kit.json records the
+template and the text boxes. The headline is LAUNCH.md's headline role
+beside the take or --headline (with none, the headline templates stand
+down for card-on-gradient, said); --kicker overrides the wordmark plus
+--release line. --poster names a bundled template for every card, your
+own template (a config.json or a hosted vos id carrying a template
+block), or none to keep the take path.
+Every video cut but the README loop opens on an ENTRANCE (tilt-in by
+default: the card swings in from a perspective pose and settles) and
+closes on an END CARD (the last frame holds 2.5 s while the card recedes
+and the headline, the release line and the wordmark rise); LAUNCH.md's
+entrance and endCard roles, or --entrance and --end-card, change or
+switch them off. A step's caption in actions.json lands as a lower-third
+at the step's moment on cuts that take words (--captions none to skip).
+Destinations that play sound (the X cut, the YouTube demo, the vertical
+cut) take a music bed from LAUNCH.md's music role (a catalog slug or a
+mood; --music overrides) and a click sound on every press when the take
+has no mic (--clicks none). The 9:16 cut is a reframe, not a letterbox:
+the crop follows the camera. --shot-time <t> picks the take moment (OUTPUT seconds;
 default the first still time \u2014 pick a zoom apex, the cut's camera makes
 the shot the feature, not the whole page); --poster-time <t> is the instant
 inside the poster's OWN timeline (default 90% through it). Screenshot-genre
@@ -6608,7 +8879,26 @@ policy); --composed keeps the cut's camera and chrome instead. --set
 path=value overrides the doc in memory for every render here (the user's
 sets apply last). Store uploads stay manual: hand the human the kit
 directory, then vos validate <kit.json> re-measures every asset from its
-bytes against the channel specs.
+bytes against the channel specs; --picture adds what each asset LOOKS
+like, read from its pixels: blank (a wallpaper or an empty canvas where
+the product should be), duplicate (two stills of one frame), subject (the
+card off the 60 to 92% band, or a crop where a card was asked for),
+separation (a light card on a light ground with no shadow), halfsize (a
+tile that loses its edges when the store shrinks it), and, where the kit
+records its text boxes, sliced, safe and contrast (APCA Lc 60/75); a
+video's first and last frames are read through ffmpeg. Every finding
+carries a code, a severity, a fix hint and a box; an error fails the
+verdict beside the spec problems.
+judge puts the kit beside its REFERENCES: for every still that has a
+reference of its role in the manifest (a template family, a card genre),
+two sheets at a common height (the asset left, then right, so order
+cannot bias the call) and the rubric in words, plus judge.json, a slot
+per pair the judge fills (win true, false or null for a tie, with the
+rule numbers). No model runs inside the verb: the skill judges the
+sheets pairwise, both orders, and the verb reports the win rate beside
+the spec and picture counts. The reference set is the maker's own
+fixture folder with a MANIFEST.json (id, file, role, layout, facts,
+rule per asset).
 brand writes the product's BRAND.md, witnessed: it reads /design.md when
 the site publishes one (the convention beside /llms.txt: fonts, logo assets,
 an avoid list), /llms.txt for the name and the claim, then the page itself
@@ -6670,7 +8960,7 @@ lint-gated, so a bad override fails like a bad doc.json):
                        first ready loop (the house backdrop the studio opens on), or a flat ground offline
 `;
 async function loadActions(file) {
-  const raw = JSON.parse(await readFile9(file, "utf8"));
+  const raw = JSON.parse(await readFile12(file, "utf8"));
   const errors = validateActions(raw);
   if (errors.length)
     throw new UsageError(`invalid actions file:
@@ -6726,16 +9016,16 @@ 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 = resolve6(strFlag(flags, "out") ?? "take");
+  const outDir = resolve7(strFlag(flags, "out") ?? "take");
   const backdrop = await takeBackdrop(flags, r);
   const maxDurationSeconds = await maxDuration(flags, r);
-  if (existsSync10(join14(outDir, "meta.json"))) {
+  if (existsSync12(join15(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" : "")
     );
   }
-  await mkdir7(outDir, { recursive: true });
+  await mkdir8(outDir, { recursive: true });
   const paths = await ensureTakeDir(outDir);
   const browser = await launchBrowser();
   try {
@@ -6776,7 +9066,7 @@ async function cmdRecord(argv) {
       },
       strictFail ? `STRICT: take recorded but incomplete \u2014 ${strictReason(rec)}; fix the flow and re-record.${skippedNote}` : `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${rec.freezePct >= 25 ? " \u26A0 keep motion in frame or trim" : ""}${skippedNote}
-  Next: edit ${join14(outDir, "doc.json")} (optional), then: vos render ${outDir}`
+  Next: edit ${join15(outDir, "doc.json")} (optional), then: vos render ${outDir}`
     );
     return strictFail ? EXIT_USAGE : EXIT_OK;
   } finally {
@@ -6800,25 +9090,25 @@ 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 = resolve6(strFlag(flags, "out") ?? "take");
+  const outDir = resolve7(strFlag(flags, "out") ?? "take");
   const fmtRaw = strFlag(flags, "format") ?? "webm";
   if (fmtRaw !== "webm" && fmtRaw !== "mp4")
     throw new UsageError("--format must be webm or mp4");
   const format = fmtRaw;
-  const out = positionals[0] ?? join14(outDir, `out.${format}`);
+  const out = positionals[0] ?? join15(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");
   }
   const backdrop = await takeBackdrop(flags, r);
   const maxDurationSeconds = await maxDuration(flags, r);
-  if (existsSync10(join14(outDir, "meta.json"))) {
+  if (existsSync12(join15(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" : "")
     );
   }
-  await mkdir7(outDir, { recursive: true });
+  await mkdir8(outDir, { recursive: true });
   const paths = await ensureTakeDir(outDir);
   const browser = await launchBrowser();
   try {
@@ -6899,24 +9189,24 @@ async function cmdPlan(argv) {
     );
   const r = createReporter(flags.json === true);
   if (flags.fresh === true) {
-    await rm4(join14(dir, "doc.json"), { force: true });
+    await rm4(join15(dir, "doc.json"), { force: true });
     r.log("note: --fresh discarded the existing doc.json");
   }
   let reuse;
   if (flags.reuse === true) {
-    const from = resolve6(strFlag(flags, "from") ?? join14(dir, PREV_DOC_NAME));
-    if (!existsSync10(from)) {
+    const from = resolve7(strFlag(flags, "from") ?? join15(dir, PREV_DOC_NAME));
+    if (!existsSync12(from)) {
       throw new UsageError(
         `--reuse: ${from} does not exist \u2014 a re-record into this take writes doc.prev.json, or pass --from <doc.json>`
       );
     }
     reuse = {
       from,
-      doc: JSON.parse(await readFile9(from, "utf8"))
+      doc: JSON.parse(await readFile12(from, "utf8"))
     };
   }
   const style = await resolveStyleRef(flags);
-  const backdrop = existsSync10(join14(dir, "doc.json")) ? null : await takeBackdrop(flags, r);
+  const backdrop = existsSync12(join15(dir, "doc.json")) ? null : await takeBackdrop(flags, r);
   const s = await planTake(dir, {
     ...style ? { style } : {},
     ...reuse ? { reuse } : {},
@@ -6928,7 +9218,7 @@ async function cmdPlan(argv) {
     ${s.reuse.flagged.join("\n    ")}` : "") : "";
   r.done(
     {
-      take: resolve6(dir),
+      take: resolve7(dir),
       fresh: s.fresh,
       cursorKept: s.cursorKept,
       zoomAuto: s.zoomAuto,
@@ -6938,7 +9228,7 @@ async function cmdPlan(argv) {
       ...s.styleFrom ? { styleFrom: s.styleFrom, styleFields: s.styleFields } : {},
       ...s.reuse ? { reuse: s.reuse } : {}
     },
-    `${s.reuse ? "Reused" : s.fresh ? "Planned" : "Refreshed"} ${join14(dir, "doc.json")}: ${s.zoomAuto} auto + ${s.zoomManual} manual zoom spans${s.cursorKept ? "" : " (cursor track dropped)"}${reuseLines}`
+    `${s.reuse ? "Reused" : s.fresh ? "Planned" : "Refreshed"} ${join15(dir, "doc.json")}: ${s.zoomAuto} auto + ${s.zoomManual} manual zoom spans${s.cursorKept ? "" : " (cursor track dropped)"}${reuseLines}`
   );
   return EXIT_OK;
 }
@@ -6958,7 +9248,7 @@ async function cmdRender(argv) {
   if (fmtRaw !== "webm" && fmtRaw !== "mp4")
     throw new UsageError("--format must be webm or mp4");
   const format = fmtRaw;
-  const out = positionals[1] ?? join14(dir, `out.${format}`);
+  const out = positionals[1] ?? join15(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");
@@ -7034,7 +9324,7 @@ async function cmdFrames(argv) {
     if (!m) throw new UsageError("--size expects WxH (e.g. --size 1280x800)");
     size = { width: Number(m[1]), height: Number(m[2]) };
   }
-  const duration = totalDuration2(ratedSegments4(take.doc));
+  const duration = totalDuration2(ratedSegments6(take.doc));
   const frameRaw = strFlag(flags, "frame");
   const timesRaw = strFlag(flags, "times");
   const atZooms = flags["at-zooms"] === true;
@@ -7121,12 +9411,13 @@ async function cmdDeliver(argv) {
   }
   const take = await loadTake(dir);
   if (!take.doc) throw new UsageError(`${dir} has no doc.json \u2014 run plan first`);
-  const duration = totalDuration2(ratedSegments4(take.doc));
+  const duration = totalDuration2(ratedSegments6(take.doc));
   const timesRaw = strFlag(flags, "times");
   let times;
   if (timesRaw !== void 0) {
     try {
-      times = parseTimes(timesRaw, duration);
+      const doc = take.doc;
+      times = timesRaw.split(",").map((s) => s.trim()).filter(Boolean).map((s) => resolveStepTime(doc, s) ?? parseTimes(s, duration)[0]);
     } catch (e) {
       throw new UsageError(e instanceof Error ? e.message : String(e));
     }
@@ -7137,11 +9428,15 @@ async function cmdDeliver(argv) {
   }
   let poster;
   const posterRef = strFlag(flags, "poster");
-  if (posterRef !== void 0) {
-    if (existsSync10(posterRef)) {
+  if (posterRef === "none") {
+    poster = null;
+  } else if (posterRef !== void 0 && templateByName(posterRef)) {
+    poster = { from: `template ${posterRef}`, config: templateByName(posterRef) };
+  } else if (posterRef !== void 0) {
+    if (existsSync12(posterRef)) {
       poster = {
-        from: resolve6(posterRef),
-        config: JSON.parse(await readFile9(posterRef, "utf8"))
+        from: resolve7(posterRef),
+        config: JSON.parse(await readFile12(posterRef, "utf8"))
       };
     } else {
       const origin = platformOrigin({
@@ -7159,9 +9454,65 @@ async function cmdDeliver(argv) {
       poster = { from: posterRef, config: res.config };
     }
   }
+  let lookPick;
+  try {
+    lookPick = await resolveLook(dir, {
+      look: strFlag(flags, "look"),
+      brand: strFlag(flags, "brand")
+    });
+  } catch (e) {
+    throw new UsageError(e instanceof Error ? e.message : String(e));
+  }
+  r.log(`look: ${lookPick.from}`);
+  const launch = await readLaunchBesideTake(dir, strFlag(flags, "launch"));
+  const lines = (v) => v === null || v === void 0 ? null : v.replace(/\\n/g, "\n");
+  const words = {
+    headline: lines(strFlag(flags, "headline") ?? launch?.roles.headline),
+    kicker: lines(strFlag(flags, "kicker") ?? launch?.roles.kicker),
+    brand: strFlag(flags, "brand-name") ?? lookPick.roles?.wordmark ?? null,
+    release: strFlag(flags, "release") ?? null
+  };
+  if (launch) r.log(`words: ${launch.file}`);
+  const launchRoles = { ...launch?.roles ?? {} };
+  for (const [flag, role] of [
+    ["music", "music"],
+    ["entrance", "entrance"],
+    ["end-card", "endCard"],
+    ["captions", "captions"],
+    ["clicks", "clicks"]
+  ]) {
+    const v = strFlag(flags, flag);
+    if (v !== void 0) launchRoles[role] = v;
+  }
+  const soundWanted = channels.some(
+    (c) => ["x", "youtube", "shorts-linkedin"].includes(c)
+  );
+  let catalog = null;
+  if (soundWanted && !/^(none|off|no|false)$/i.test(launchRoles.music ?? "") && !/^(none|off|no|false)$/i.test(launchRoles.clicks ?? "")) {
+    try {
+      catalog = await fetchMusicCatalog(
+        platformOrigin({
+          origin: strFlag(flags, "origin"),
+          api: strFlag(flags, "api")
+        })
+      );
+    } catch (e) {
+      r.log(`music catalog: ${e instanceof Error ? e.message : String(e)} \u2014 the cuts stay silent`);
+    }
+  }
+  const captions = (take.actions?.steps ?? []).flatMap((s, i) => {
+    const step = s;
+    return typeof step.caption === "string" && step.caption.trim() ? [{ step: i, id: step.id, caption: step.caption.trim() }] : [];
+  });
   const browser = await launchBrowser();
   try {
     const result = await deliverTake(browser, dir, {
+      look: lookPick.look,
+      brandRoles: lookPick.roles,
+      launchRoles,
+      catalog,
+      captions,
+      words,
       channels,
       outDir: strFlag(flags, "out"),
       release: strFlag(flags, "release"),
@@ -7211,14 +9562,14 @@ Store uploads stay manual: hand the human this directory and the manifest.`
 async function resolveStyleRef(flags) {
   const styleRef = strFlag(flags, "style");
   if (!styleRef) return null;
-  const file = existsSync10(styleRef) ? resolve6(
+  const file = existsSync12(styleRef) ? resolve7(
     styleRef,
-    existsSync10(join14(styleRef, "doc.json")) ? "doc.json" : ""
+    existsSync12(join15(styleRef, "doc.json")) ? "doc.json" : ""
   ) : null;
-  if (file && existsSync10(file)) {
+  if (file && existsSync12(file)) {
     return {
       from: file,
-      doc: JSON.parse(await readFile9(file, "utf8"))
+      doc: JSON.parse(await readFile12(file, "utf8"))
     };
   }
   const origin = platformOrigin({
@@ -7255,7 +9606,7 @@ async function cmdDigest(argv) {
   const take = await loadTake(dir);
   if (!take.doc) throw new UsageError(`${dir} has no doc.json \u2014 run plan first`);
   const transcriptPath = strFlag(flags, "transcript");
-  const transcript = transcriptPath ? parseTranscript(JSON.parse(await readFile9(transcriptPath, "utf8"))) : null;
+  const transcript = transcriptPath ? parseTranscript(JSON.parse(await readFile12(transcriptPath, "utf8"))) : null;
   const style = await resolveStyleRef(flags);
   const noFrames = flags["no-frames"] === true;
   let browser = null;
@@ -7286,7 +9637,7 @@ async function cmdDigest(argv) {
         kinds,
         frames: d.images.full,
         crops: d.images.crop,
-        sheet: d.images.sheet ? join14(result.outDir, d.images.sheet) : null,
+        sheet: d.images.sheet ? join15(result.outDir, d.images.sheet) : null,
         scenes: kinds.scene ?? 0,
         sourceDuration: d.take.sourceDuration,
         outputDuration: d.take.outputDuration,
@@ -7310,14 +9661,14 @@ async function cmdOpen(argv) {
   if (!dir) throw new UsageError("vos open <take> [--studio <url>]");
   const r = createReporter(flags.json === true);
   const take = await loadTake(dir);
-  if (!existsSync10(take.paths.recording)) {
+  if (!existsSync12(take.paths.recording)) {
     throw new UsageError(`${dir} has no recording.webm \u2014 re-run record`);
   }
   const studio = (strFlag(flags, "studio") ?? "http://localhost:6060").replace(
     /\/+$/,
     ""
   );
-  const server = await startTakeServer(resolve6(dir), {});
+  const server = await startTakeServer(resolve7(dir), {});
   const url = `${studio}/studio?take=${encodeURIComponent(server.base)}`;
   r.event({ event: "open", server: server.base, url });
   r.log(`take served at ${server.base}`);
@@ -7342,22 +9693,57 @@ async function cmdOpen(argv) {
   });
   return EXIT_OK;
 }
+async function cmdJudge(argv) {
+  const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS5);
+  const target = positionals[0];
+  const against = strFlag(flags, "against");
+  if (!target || !against)
+    throw new UsageError(
+      "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 : join15(target, "kit.json");
+  if (!existsSync12(kitFile)) throw new UsageError(`${kitFile}: no kit manifest`);
+  if (!existsSync12(against)) throw new UsageError(`${against}: no reference manifest`);
+  const result = await judgeKit(kitFile, against, strFlag(flags, "out"));
+  const verdicts = JSON.parse(await readFile12(result.verdictFile, "utf8")).verdicts;
+  const rate = winRate(verdicts);
+  const lines = result.sheets.map(
+    (s) => `${s.asset} vs ${s.reference}: ${s.sheetA}, ${s.sheetB}, ${s.rubric}`
+  );
+  r.done(
+    { ...result, winRate: rate },
+    `Wrote ${result.sheets.length} sheet pair(s) to ${result.outDir}` + (lines.length ? `
+  ${lines.join("\n  ")}` : "") + (result.skipped.length ? `
+  skipped: ${result.skipped.join("\n  skipped: ")}` : "") + `
+Judge each pair both ways (the rubric is beside it) and fill ${result.verdictFile}` + (rate.judged ? `
+Win rate so far: ${rate.wins}/${rate.judged} (${(rate.rate * 100).toFixed(0)}%); parity with the references is 50%, the marketability bar is 40%` : "")
+  );
+  return EXIT_OK;
+}
 async function cmdValidate(argv) {
   const { positionals, flags } = parseArgs(argv, BOOLEAN_FLAGS5);
   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 : existsSync10(join14(target, "kit.json")) && !isTakeDir(target) ? join14(target, "kit.json") : null;
+  const kitTarget = target.endsWith("kit.json") ? target : existsSync12(join15(target, "kit.json")) && !isTakeDir(target) ? join15(target, "kit.json") : null;
   if (kitTarget) {
-    const verdict = await validateKit(kitTarget);
-    const tail = verdict.warnings.length ? `
+    const picture = flags.picture === true;
+    const verdict = await validateKit(kitTarget, { picture });
+    const pictureLines = (verdict.picture ?? []).map(formatFinding);
+    const pictureErrors = (verdict.picture ?? []).filter(
+      (f) => f.severity === "error"
+    ).length;
+    const tail = (verdict.warnings.length ? `
   warnings:
-  ${verdict.warnings.join("\n  ")}` : "";
+  ${verdict.warnings.join("\n  ")}` : "") + (picture ? `
+  picture: ${pictureErrors} problem(s), ${(verdict.picture ?? []).length - pictureErrors} note(s)` + (pictureLines.length ? `
+  ${pictureLines.join("\n  ")}` : "") : "");
     if (!verdict.valid) {
       r.done(
         { ...verdict, target: kitTarget },
-        `${kitTarget}:
-  ${verdict.problems.join("\n  ")}${tail}`
+        `${kitTarget}:${verdict.problems.length ? `
+  ${verdict.problems.join("\n  ")}` : ""}${tail}`
       );
       return EXIT_ERROR;
     }
@@ -7372,9 +9758,9 @@ async function cmdValidate(argv) {
     r.done({ valid: true, target }, `${target}: valid actions file`);
     return EXIT_OK;
   }
-  if (!isTakeDir(target) && existsSync10(join14(target, "config.json"))) {
+  if (!isTakeDir(target) && existsSync12(join15(target, "config.json"))) {
     const parsed = JSON.parse(
-      await readFile9(join14(target, "config.json"), "utf8")
+      await readFile12(join15(target, "config.json"), "utf8")
     );
     const pre = preflightConfig(parsed);
     const problems2 = pre.ok ? [] : pre.issues.map((i) => `config.json: ${i}`);
@@ -7415,7 +9801,7 @@ async function cmdValidate(argv) {
   const take = await loadTake(target);
   const problems = [];
   const warnings = [];
-  if (!existsSync10(take.paths.recording))
+  if (!existsSync12(take.paths.recording))
     problems.push("missing recording.webm (re-run record)");
   if (!take.doc) problems.push("missing doc.json (run plan)");
   if (take.doc) {
@@ -7460,7 +9846,7 @@ async function cmdPush3(argv) {
   const r = createReporter(flags.json === true);
   const overrides = multi.override;
   const result = await pushTake(
-    resolve6(dir),
+    resolve7(dir),
     {
       key: strFlag(flags, "key"),
       api: strFlag(flags, "api"),
@@ -7487,16 +9873,25 @@ async function cmdPull2(argv) {
   const dir = positionals[0] ?? ".";
   const r = createReporter(flags.json === true);
   const result = await pullTake(
-    resolve6(dir),
+    resolve7(dir),
     {
       key: strFlag(flags, "key"),
       api: strFlag(flags, "api"),
       origin: strFlag(flags, "origin"),
       vos: strFlag(flags, "vos"),
-      media: flags.media === true
+      media: flags.media === true,
+      since: strFlag(flags, "since"),
+      check: flags.check === true
     },
     r
   );
+  if (result.checked) {
+    r.done(
+      { ...result },
+      result.behind === null ? `${result.vosId}: head is ${result.versionId.slice(0, 8)}\u2026 \u2014 no base to count from; run without --check to sync` : result.behind === 0 ? `${result.vosId}: up to date` : `${result.behind} version${result.behind === 1 ? "" : "s"} behind \u2014 run without --check to sync`
+    );
+    return EXIT_OK;
+  }
   const mediaLine = result.media ? result.media.downloaded.length ? ` + ${result.media.downloaded.map((m) => m.file).join(", ")} (footage home \u2014 digest/frames/render run here now)` : result.media.kept.length ? ` (footage already here: ${result.media.kept.join(", ")})` : " (no hosted media on this doc)" : "";
   r.done(
     { ...result },
@@ -7530,6 +9925,8 @@ async function run(argv) {
         return await cmdOpen(rest);
       case "validate":
         return await cmdValidate(rest);
+      case "judge":
+        return await cmdJudge(rest);
       case "fetch":
         return await cmdFetch(rest);
       case "duplicate":
@@ -7611,4 +10008,4 @@ export {
   convertAgentBrowser,
   run
 };
-//# sourceMappingURL=chunk-6TFKMNSG.js.map
+//# sourceMappingURL=chunk-MMKDYE57.js.map