@ignix-social/editor 0.1.10 → 0.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ignix-social/editor",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Ignix Editor: render HTML video compositions (reels, edits, clips) on your own computer. Based on HyperFrames.",
   "license": "Apache-2.0",
   "type": "module",

package/skills/ignix-editor/SKILL.md

@@ -139,8 +139,12 @@ Re-run it whenever the voice or the cuts change; the animation code reads `windo
 
 ## 7. Review before showing anything
 
-`check`, `snapshot` and `render` start a headless Chrome. A sandboxed shell can block it (Codex: `MachPortRendezvousServer: Permission denied`, or `Chrome cannot start`): run those commands with the host's escalated permissions, outside its sandbox — in Codex, request escalated permissions for the command. If the host cannot, give the user ONE line to paste into Terminal, e.g. `cd ~/ignix-videos/<name> && ~/.ignix-editor/cli/node_modules/.bin/ignix-editor render`, never the contents of a script file (a `#!` line breaks zsh), then continue when they say it finished.
+`check`, `snapshot` and `render` start a headless Chrome. A sandboxed shell can block it (Codex: `MachPortRendezvousServer: Permission denied`, or `Chrome cannot start`): first run those commands with the host's escalated permissions, outside its sandbox. If the host still blocks it, stop and tell the user how to allow it in their app, then retry when they say it is done:
+- ChatGPT / Codex app: Settings → General → Permissions → turn on "Full access" and confirm; then, in the chat, open the approvals selector under the message box and choose "Full access" (labels follow the app's language; they can switch back to "Ask for approval" after the render).
+- Claude Code: approve the command when asked; if its sandbox blocks Chrome, allow that command outside the sandbox (or turn the sandbox off with `/sandbox`).
+
+Only if the app offers no way, give the user ONE line to paste into Terminal, e.g. `cd ~/ignix-videos/<name> && ~/.ignix-editor/cli/node_modules/.bin/ignix-editor render`, never the contents of a script file (a `#!` line breaks zsh), then continue when they say it finished.
 
 1. `ignix-editor check` → 0 errors.
 2. `ignix-editor snapshot --at <every ~0.5 s and every cue>` and LOOK at the frames (or tile them: `ignix-editor ffmpeg -pattern_type glob -i 'snapshots/frame-*.png' -vf "scale=270:480,tile=8x2" sheet.jpg`). Check: hook readable at frame 0, nothing still for >1.5 s, every named thing pointed at on its word, captions never over what is pointed at, nothing outside the safe zone.
-3. `ignix-editor render` → open the MP4's first frame and a few cues again; then deliver as the playbook says.
+3. `ignix-editor render` → it reviews the MP4 by itself and prints `✓ Review: ready to show` or `✗ Review: NOT READY` with what to fix and where (stretches where nothing on the stage moves, a mostly empty frame, silences between voice lines, no change of scene, no sound effects). NOT READY means it is not finished: fix every ✗, render again, and only then show it. The `!` lines are worth fixing too when it is quick. (`ignix-editor review <mp4>` runs the same check on any video.) Then open the MP4's first frame and a few cues again, and deliver as the playbook says.

package/src/analysis/review.mjs

@@ -0,0 +1,216 @@
+import { frames, levels, probe } from './media.mjs';
+import { measureVideo } from './style.mjs';
+
+// REVISIÓN DE UN REEL ANTES DE ENSEÑARLO (2026-10-06). El manual pide «algo cambia cada
+// 1-1,5 s», «llena el plano», «voz sin huecos», «efectos que signifiquen algo»… y un agente
+// con prisa no lo mira: en la prueba de Fran con ChatGPT salió un carrusel de cinco tarjetas
+// pequeñas, quietas 3-4 s cada una, con 0,8 s de silencio entre frases. Esto lo MIDE en el
+// MP4 y dice qué arreglar y dónde, para que no dependa de que el agente se fije.
+//
+// Medidas (sobre el vídeo ya renderizado, sin saber cómo se hizo):
+//   quieto   — tramos en los que el escenario no cambia: diferencia entre fotogramas
+//              consecutivos por debajo de lo que mueve una palabra de subtítulo al
+//              encenderse. Los subtítulos solos NO cuentan como movimiento.
+//   lleno    — qué parte de la zona segura ocupa algo distinto del fondo.
+//   huecos   — silencios entre frases de la voz.
+//   cortes y efectos — los de `style measure` (cambios de escena, efectos oídos).
+
+const FPS = 10;
+/** Fracción de píxeles que tiene que cambiar entre dos fotogramas para contar como movimiento. */
+export const MOVE_FRAC = 0.006;
+/** Tramo quieto que ya es un fallo (el manual dice ~1,5 s; margen de sobra: con 2-2,5 s
+ *  fallaban reels buenos de Fran en pausas que nadie nota). En vídeos de más de
+ *  {@link LONG_SEC} es solo un aviso: ahí se explica más despacio. */
+export const STILL_FAIL_SEC = 3;
+/** La tarjeta final puede quedarse quieta algo más (CTA que se lee). */
+export const END_HOLD_SEC = 3.5;
+export const LONG_SEC = 35;
+/** Franja de los subtítulos (el manual los pone abajo en la columna segura): no cuenta como
+ *  movimiento, porque un carrusel quieto con subtítulos palabra a palabra «se mueve». */
+const CAPTION_BAND = { y0: 0.6, y1: 0.8 };
+/** Por debajo de esta ocupación media de la zona segura, el plano está medio vacío. */
+// Calibrado con reels que Fran da por buenos (2026-10-06): 0,28-0,80; el carrusel flojo, 0,19.
+export const FILL_FAIL = 0.22;
+export const FILL_WARN = 0.25;
+/** Silencio entre dos frases que ya se nota (el manual pide ≤ 0,3 s). */
+export const GAP_WARN_SEC = 0.5;
+const SILENCE_DB = -45;
+
+// Zona segura de un 9:16 de 1080×1920 (la del manual): columna central de ~820 px, sin los
+// ~250 px de arriba ni los ~450 de abajo.
+const SAFE = { x0: 0.12, x1: 0.88, y0: 0.13, y1: 0.765 };
+
+function gray(rgb, n) {
+  const g = new Uint8Array(n);
+  for (let i = 0; i < n; i++) g[i] = (rgb[i * 3] * 77 + rgb[i * 3 + 1] * 150 + rgb[i * 3 + 2] * 29) >> 8;
+  return g;
+}
+
+/** El color de fondo: la mediana de los bordes del fotograma. */
+function background(rgb, w, h) {
+  const rs = [];
+  const gs = [];
+  const bs = [];
+  const take = (x, y) => {
+    const i = (y * w + x) * 3;
+    rs.push(rgb[i]);
+    gs.push(rgb[i + 1]);
+    bs.push(rgb[i + 2]);
+  };
+  for (let x = 0; x < w; x += 2) {
+    take(x, 0);
+    take(x, h - 1);
+  }
+  for (let y = 0; y < h; y += 2) {
+    take(0, y);
+    take(w - 1, y);
+  }
+  const med = (a) => a.sort((p, q) => p - q)[a.length >> 1];
+  return [med(rs), med(gs), med(bs)];
+}
+
+/** Qué parte de la zona segura ocupa algo distinto del fondo (0..1). */
+export function fillOf(rgb, w, h) {
+  const [br, bg, bb] = background(rgb, w, h);
+  const x0 = Math.round(SAFE.x0 * w);
+  const x1 = Math.round(SAFE.x1 * w);
+  const y0 = Math.round(SAFE.y0 * h);
+  const y1 = Math.round(SAFE.y1 * h);
+  let on = 0;
+  let n = 0;
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      const i = (y * w + x) * 3;
+      if (Math.abs(rgb[i] - br) + Math.abs(rgb[i + 1] - bg) + Math.abs(rgb[i + 2] - bb) > 60) on++;
+      n++;
+    }
+  }
+  return n ? on / n : 0;
+}
+
+/** Tramos seguidos de pasos sin movimiento, en segundos [{start, end}]. */
+export function stillRuns(steps, minSec) {
+  const out = [];
+  let from = null;
+  for (let i = 0; i <= steps.length; i++) {
+    const still = i < steps.length && steps[i].frac < MOVE_FRAC;
+    if (still && from === null) from = i;
+    if (!still && from !== null) {
+      const start = steps[from].t - 1 / FPS;
+      const end = steps[i - 1].t;
+      if (end - start >= minSec) out.push({ start, end });
+      from = null;
+    }
+  }
+  return out;
+}
+
+/** Silencios dentro de la voz (entre la primera y la última ventana con sonido). */
+export function speechGaps(db, windowSec, minSec) {
+  const loud = db.map((v) => v > SILENCE_DB);
+  const first = loud.indexOf(true);
+  const last = loud.lastIndexOf(true);
+  if (first < 0) return [];
+  const out = [];
+  let from = null;
+  for (let i = first; i <= last; i++) {
+    if (!loud[i] && from === null) from = i;
+    if (loud[i] && from !== null) {
+      const sec = (i - from) * windowSec;
+      if (sec >= minSec) out.push({ start: from * windowSec, end: i * windowSec });
+      from = null;
+    }
+  }
+  return out;
+}
+
+const r1 = (x) => Math.round(x * 10) / 10;
+
+export async function reviewVideo({ ffmpeg, ffprobe, path, log = () => {} }) {
+  const info = probe(ffprobe, path);
+  if (!info.hasVideo || !(info.duration > 0)) throw new Error(`${path} has no video`);
+  const steps = [];
+  const fills = [];
+  let prev = null;
+  let k = 0;
+  log('Reviewing motion and framing…');
+  await frames(ffmpeg, path, {
+    fps: FPS,
+    max: 240,
+    width: info.width,
+    height: info.height,
+    onFrame: (f) => {
+      const n = f.w * f.h;
+      const g = gray(f.rgb, n);
+      if (prev) {
+        const c0 = Math.round(CAPTION_BAND.y0 * f.h) * f.w;
+        const c1 = Math.round(CAPTION_BAND.y1 * f.h) * f.w;
+        let c = 0;
+        for (let i = 0; i < n; i++) if ((i < c0 || i >= c1) && Math.abs(g[i] - prev[i]) > 16) c++;
+        steps.push({ t: f.t, frac: c / (n - (c1 - c0)) });
+      }
+      prev = g;
+      if (k++ % 5 === 0) fills.push(fillOf(f.rgb, f.w, f.h));
+    },
+  });
+  const windowSec = 0.05;
+  const db = await levels(ffmpeg, path, { windowSec }).catch(() => null);
+  log('Reviewing text and sound…');
+  const m = await measureVideo({ ffmpeg, ffprobe, path, log: () => {} }).catch(() => null);
+
+  // La última quietud, si llega al final, es la tarjeta de cierre: se le deja más.
+  const stills = stillRuns(steps, STILL_FAIL_SEC).filter(
+    (s) => !(info.duration - s.end < 0.3 && s.end - s.start < END_HOLD_SEC),
+  );
+  const fill = fills.length ? fills.reduce((a, b) => a + b, 0) / fills.length : null;
+  const gaps = db ? speechGaps(db, windowSec, GAP_WARN_SEC) : [];
+  const movingShare = steps.length ? steps.filter((s) => s.frac >= MOVE_FRAC).length / steps.length : null;
+
+  const issues = [];
+  for (const s of stills) {
+    issues.push({
+      level: info.duration > LONG_SEC ? 'warn' : 'fail',
+      code: 'still',
+      at: [r1(s.start), r1(s.end)],
+      text: `Nothing on the stage moves from ${r1(s.start)} s to ${r1(s.end)} s (${r1(s.end - s.start)} s; captions alone do not count). Add a camera move, an element entering or a highlight at least every 1-1.5 s.`,
+    });
+  }
+  if (fill !== null && fill < FILL_WARN) {
+    issues.push({
+      level: fill < FILL_FAIL ? 'fail' : 'warn',
+      code: 'empty_frame',
+      text: `The frame is mostly empty: only ${Math.round(fill * 100)} % of the safe area has something on it. Make the stage (phone, screen, card, image) about 85 % of the safe column's width and most of its height.`,
+    });
+  }
+  for (const gp of gaps) {
+    issues.push({
+      level: 'warn',
+      code: 'speech_gap',
+      at: [r1(gp.start), r1(gp.end)],
+      text: `${r1(gp.end - gp.start)} s of silence between two voice lines at ${r1(gp.start)} s. Lay the lines back to back (≤ 0.3 s).`,
+    });
+  }
+  // Calibrado con los reels de Fran (2026-10-06): todos los buenos cortan 3,5-10 veces por
+  // minuto; el carrusel flojo, ninguna (solo fundidos entre tarjetas).
+  if (m?.shots?.cutsPerMinute === 0 && info.duration > 10) {
+    issues.push({ level: 'warn', code: 'no_cuts', text: 'No real change of scene anywhere: it plays as one slow sequence of fades. Change scene with cuts or quick whips, and move a camera inside each scene.' });
+  }
+  const sfx = m?.audio?.sound?.sfxPerMinute;
+  if (sfx === 0 && info.duration > 8) {
+    issues.push({ level: 'warn', code: 'no_sfx', text: 'No sound effect is heard. A 20 s reel usually needs 4-8, on the moments that matter (hook, scene change, the key click or reveal, the CTA).' });
+  }
+  return {
+    path,
+    durationSec: r1(info.duration),
+    ready: !issues.some((i) => i.level === 'fail'),
+    measured: {
+      movingShare: movingShare === null ? null : Math.round(movingShare * 100) / 100,
+      longestStillSec: r1(Math.max(0, ...stillRuns(steps, 0).map((s) => s.end - s.start))),
+      fill: fill === null ? null : Math.round(fill * 100) / 100,
+      textSize: m?.captions?.size ?? null,
+      sfxPerMinute: sfx ?? null,
+      cutsPerMinute: m?.shots?.cutsPerMinute ?? null,
+    },
+    issues,
+  };
+}

package/src/cli.mjs

@@ -18,6 +18,7 @@ import { serve } from './analysis/serve.mjs';
 import { creatorJob } from './creator/job.mjs';
 import { fetchAll } from './fetch.mjs';
 import { measureStyle } from './analysis/style.mjs';
+import { reviewVideo } from './analysis/review.mjs';
 
 const PKG_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
 const PKG = JSON.parse(readFileSync(join(PKG_DIR, 'package.json'), 'utf8'));
@@ -158,16 +159,41 @@ const commands = {
   },
 
   async render(argv) {
-    const { pos, opts, rest } = parseArgs(argv, { output: 'str', lufs: 'str', normalize: 'bool', force: 'bool' });
+    const { pos, opts, rest } = parseArgs(argv, { output: 'str', lufs: 'str', normalize: 'bool', force: 'bool', review: 'bool' });
     const dir = projectDir(pos[0]);
     if (validateProject(dir) && !opts.force) fail('Fix the errors above before rendering (or --force if you know what you are doing).');
     const output = resolve(opts.output ?? join(dir, 'renders', `${basename(dir)}.mp4`));
     const r = await renderProject(dir, output, { lufs: opts.lufs, normalize: opts.normalize, engineArgs: rest, log });
     if (r.snapped) log(`• ${r.snapped} time(s) snapped to the nearest frame`);
     if (r.loudness) log(`✓ Loudness: ${r.loudness.before.toFixed(1)} → ${r.loudness.after?.toFixed(1)} LUFS`);
+    // La revisión va SIEMPRE detrás del render (salvo --no-review): un agente con prisa se
+    // salta un paso aparte, pero no puede no ver esto. El MP4 queda hecho igualmente.
+    if (opts.review !== false) {
+      const ffmpeg = await ensureTool('ffmpeg', log);
+      const ffprobe = await ensureTool('ffprobe', log);
+      await reviewVideo({ ffmpeg, ffprobe, path: output, log })
+        .then((rv) => printReview(rv))
+        .catch((e) => log(`(The review could not run: ${e.message}. Check the frames yourself.)`));
+    }
     console.log(output);
   },
 
+  // Revisa un MP4 ya hecho: quietud, plano vacío, huecos en la voz, cortes y efectos.
+  // Sale con código 1 si no está listo para enseñarlo.
+  async review(argv) {
+    const { pos, opts } = parseArgs(argv, { json: 'bool' });
+    const input = pos[0] && resolve(pos[0]);
+    if (!input || !existsSync(input)) fail('Usage: ignix-editor review <video.mp4> [--json]');
+    const ffmpeg = await ensureTool('ffmpeg', log);
+    const ffprobe = await ensureTool('ffprobe', log);
+    const rv = await reviewVideo({ ffmpeg, ffprobe, path: input, log });
+    if (opts.json) console.log(JSON.stringify(rv, null, 1));
+    else printReview(rv, console.log);
+    // exitCode y no process.exit: cortar el proceso con onnxruntime cargado lo tumba
+    // («mutex lock failed», código 134).
+    if (!rv.ready) process.exitCode = 1;
+  },
+
   async preview(argv) {
     const { pos, rest } = parseArgs(argv, {});
     const dir = projectDir(pos[0]);
@@ -329,7 +355,8 @@ const commands = {
   ignix-editor init <name>                     creates ~/ignix-videos/<name>, ready to work in
   ignix-editor check [folder]                  HTML, assets, layout, motion and contrast
   ignix-editor snapshot [folder] --at 0,2.5,5  single frames to look at (into <folder>/snapshots)
-  ignix-editor render [folder] [-o out.mp4] [--lufs -14] [--no-normalize]
+  ignix-editor render [folder] [-o out.mp4] [--lufs -14] [--no-normalize] [--no-review]
+  ignix-editor review <video.mp4> [--json]     is it ready to show? stillness, empty frame, voice gaps, cuts, sound effects
   ignix-editor preview [folder]                live preview in the browser
   ignix-editor transcribe <file> [--lang es] [--script "text"] [-o words.json]
   ignix-editor faces <video> [--every 0.2] [-o faces.json]   where the face is, smoothed
@@ -343,6 +370,12 @@ The folder defaults to the current one. Open source (Apache-2.0); credits in NOT
   },
 };
 
+function printReview(rv, out = log) {
+  out(rv.ready ? '✓ Review: ready to show.' : '✗ Review: NOT READY. Fix every ✗ below, render again, and only then show it to the user.');
+  for (const i of rv.issues) out(`  ${i.level === 'fail' ? '✗' : '!'} ${i.text}`);
+  if (rv.ready && rv.issues.length) out('  (! = worth fixing if it is quick.)');
+}
+
 export async function main(argv) {
   const [cmd = 'help', ...rest] = argv;
   const fn = commands[cmd === '--version' || cmd === '-v' ? 'version' : cmd === '--help' || cmd === '-h' ? 'help' : cmd];