@mevdragon/vidfarm-devcli 0.13.0 → 0.15.0

package/.agents/skills/embedded-captions/scripts/lib-dna.cjs

@@ -0,0 +1,201 @@
+/*
+ * lib-dna.cjs — DNA registry loader + scene-token resolver.
+ *
+ * A DNA is a complete visual language (type, palette logic, motion grammar, hero
+ * orchestration) that PARAMETERIZES per scene instead of shipping fixed look files.
+ * The resolver folds in safe-zones.json's v2 scene measurements (palette / optics /
+ * lighting) and envelope.json's loudness so the compiled tokens fit THIS clip:
+ *
+ *   accent      — scene-sampled when the DNA says "scene" (clamped readable)
+ *   text shadow — contact shadow cast along the measured light direction
+ *   depth match — embed text blur follows the scene's depth-of-field
+ *   hero amp    — entrance amplitude coupled to the spoken word's loudness (RMS)
+ *
+ * Everything is read from files written by deterministic scripts — no randomness.
+ */
+const path = require("path");
+const fs = require("fs");
+
+const SKILL_ROOT = path.resolve(__dirname, "..");
+const DNA_DIR = path.join(SKILL_ROOT, "dna");
+
+// legacy template names → DNA (back-compat for existing plan.json files)
+const LEGACY = { "cinematic-cream": "cream" };
+
+function list() {
+  try {
+    return fs
+      .readdirSync(DNA_DIR)
+      .filter((f) => f.endsWith(".json"))
+      .map((f) => f.replace(/\.json$/, ""))
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function load(name) {
+  const p = path.join(DNA_DIR, `${name}.json`);
+  if (!fs.existsSync(p)) {
+    throw new Error(`unknown DNA "${name}". Available: ${list().join(", ")}`);
+  }
+  return JSON.parse(fs.readFileSync(p, "utf8"));
+}
+
+function readJson(p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+// ── audio impact: where does this window's loudness rank within the clip? ──────
+// envelope.json = { hop, rms: [linear 0..1 per hop] } (audio-envelope.cjs)
+function heroImpact(project, t0, t1) {
+  const env = readJson(path.join(project, "envelope.json"));
+  if (!env || !Array.isArray(env.rms) || !env.rms.length) return 0.6; // neutral default
+  const hop = env.hop || 0.05;
+  const i0 = Math.max(0, Math.floor(t0 / hop)),
+    i1 = Math.min(env.rms.length, Math.ceil(t1 / hop));
+  if (i1 <= i0) return 0.6;
+  const span = i1 - i0;
+  const mean = (arr, a, b) => {
+    let s = 0;
+    for (let i = a; i < b; i++) s += arr[i];
+    return s / (b - a);
+  };
+  const target = mean(env.rms, i0, i1);
+  // percentile of this window vs all same-length windows across the clip
+  let below = 0,
+    total = 0;
+  for (let s = 0; s + span <= env.rms.length; s += Math.max(1, Math.floor(span / 2))) {
+    total++;
+    if (mean(env.rms, s, s + span) <= target) below++;
+  }
+  return total ? below / total : 0.6;
+}
+
+// ── scene-aware token resolution ───────────────────────────────────────────────
+function resolveTokens(dna, project, opts) {
+  const sz = readJson(path.join(project, "safe-zones.json")) || {};
+  const palette = sz.palette || {};
+  const optics = sz.optics || {};
+  const lighting = sz.lighting || {};
+
+  // accent: "scene" → sampled suggestion, else literal.
+  // accentMode "counter" (loud registers): the accent must FIGHT the scene's
+  // temperature, not harmonize with it — a sampled warm sienna inside a tungsten room
+  // camouflages (the warm-on-warm failure a blind review caught across three DNAs).
+  // Counter-pole = rotate the sampled hue 180° and push saturation/lightness hot.
+  let accent =
+    dna.palette.accent === "scene"
+      ? palette.accentSuggestion || dna.palette.accent_fallback || "#e3c06a"
+      : dna.palette.accent;
+  if (
+    dna.palette.accentMode === "counter" &&
+    dna.palette.accent === "scene" &&
+    /^#([0-9a-f]{6})$/i.test(accent || "")
+  ) {
+    const n = parseInt(accent.slice(1), 16);
+    let r = (n >> 16) / 255,
+      g2 = ((n >> 8) & 255) / 255,
+      b = (n & 255) / 255;
+    const mx = Math.max(r, g2, b),
+      mn = Math.min(r, g2, b),
+      d = mx - mn;
+    let h = 0;
+    if (d > 0) {
+      h = mx === r ? ((g2 - b) / d) % 6 : mx === g2 ? (b - r) / d + 2 : (r - g2) / d + 4;
+      h *= 60;
+      if (h < 0) h += 360;
+    }
+    h = (h + 180) % 360;
+    const s = 0.85,
+      v = 0.92; // hot, acid, readable
+    const c = v * s,
+      x = c * (1 - Math.abs(((h / 60) % 2) - 1)),
+      m = v - c;
+    const [r2, g3, b2] =
+      h < 60
+        ? [c, x, 0]
+        : h < 120
+          ? [x, c, 0]
+          : h < 180
+            ? [0, c, x]
+            : h < 240
+              ? [0, x, c]
+              : h < 300
+                ? [x, 0, c]
+                : [c, 0, x];
+    const f = (q) =>
+      Math.round((q + m) * 255)
+        .toString(16)
+        .padStart(2, "0");
+    accent = `#${f(r2)}${f(g3)}${f(b2)}`;
+  }
+
+  const dark = dna.palette.scheme === "dark-on-light";
+
+  // contact shadow along the measured light direction + a soft ambient.
+  // light-on-dark also gets the warm bloom layer when the DNA asks for it.
+  let shadowParts = [];
+  if (dna.optics && dna.optics.contactShadow) {
+    const sd = lighting.shadow || { dx: 0, dy: 3 };
+    shadowParts.push(`${sd.dx}px ${sd.dy + 1}px 10px rgba(0,0,0,${dark ? 0.22 : 0.32})`);
+  }
+  shadowParts.push(dark ? "0 1px 14px rgba(0,0,0,0.10)" : "0 2px 22px rgba(0,0,0,0.28)");
+  if (dna.optics && dna.optics.warmBloom) shadowParts.push("0 0 26px rgba(255,214,160,0.18)");
+  const textShadow = shadowParts.join(", ");
+
+  // depth match: embed (bg) text picks up the scene's bokeh; fg/rail stay sharp
+  const blurPx = (dna.optics && dna.optics.depthMatch && optics.suggestedTextBlurPx) || 0;
+  const baseFilter = dna.filter && dna.filter !== "none" ? dna.filter : "";
+  const filterBg = `${baseFilter}${blurPx ? ` blur(${blurPx}px)` : ""}`.trim() || "none";
+  const filterFg = baseFilter || "none";
+
+  // hero orchestration + loudness coupling — one config PER hero (scarcity is per
+  // beat/block, not per clip; each hero's amplitude follows ITS spoken loudness)
+  const heroGroups = (opts && (opts.heroGroups || (opts.heroGroup ? [opts.heroGroup] : []))) || [];
+  const heroes = heroGroups.map((hg) => {
+    const impact = heroImpact(project, hg.in, Math.min(hg.in + 0.7, hg.out));
+    const amp = +((0.75 + impact * 0.5) * (hg.minor ? 0.7 : 1)).toFixed(3); // 0.75…1.25, minors damped
+    return {
+      // spread the DNA's full hero block (entrance/perLetter/glow/breathe/ripple/loom/
+      // letterBlur/sheen/echoes/… — new fx fields flow through with no plumbing),
+      // then the per-hero computed values
+      ...dna.hero,
+      entrance: dna.hero.entrance || "emergence",
+      dimOthers: dna.hero.dimOthers != null ? dna.hero.dimOthers : 0.45,
+      id: hg.id,
+      minor: hg.minor === true,
+      in: hg.in,
+      out: hg.out,
+      amp,
+      heroColor: dna.palette.heroColor === "accent" ? accent : null,
+    };
+  });
+  const hero = heroes[0] || null; // back-compat single accessor
+
+  return {
+    fontFamily: dna.font.family,
+    capColor: dna.palette.cap_color,
+    blend: dna.palette.blend,
+    accent,
+    textShadow,
+    filterBg,
+    filterFg,
+    blurPx,
+    motion: dna.motion,
+    hero,
+    heroes,
+    heroCss: (dna.hero && dna.hero.css) || "",
+    heroCase: (dna.hero && dna.hero.case) || "none",
+    heroTracking: (dna.hero && dna.hero.tracking) || "0",
+    dnaCss: dna.css || "",
+    register: dna.register,
+    name: dna.name,
+  };
+}
+
+module.exports = { LEGACY, list, load, resolveTokens, heroImpact };