@ignix-social/editor 0.1.3 → 0.1.6

package/NOTICE

@@ -20,9 +20,11 @@ this package)
 FFmpeg 7.1.2 (ffmpeg, ffprobe) — https://ffmpeg.org
   Licensed under the GNU General Public License, version 2 or later. Its full text
   is in licenses/ffmpeg-GPL-2.0.txt. Built with --enable-gpl --disable-nonfree and
-  without libx264 (it encodes with Apple's VideoToolbox), using
-  scripts/build-ffmpeg-macos.sh in this repository, which records the exact
-  configuration. The corresponding source code is available at
+  without libx264 (it encodes with Apple's VideoToolbox on macOS and Microsoft
+  Media Foundation on Windows), using scripts/build-ffmpeg-macos.sh and
+  scripts/build-ffmpeg-windows.sh (cross-compiled with MinGW-w64; it statically
+  includes zlib, under the zlib licence) in this repository, which record the
+  exact configuration. The corresponding source code is available at
   https://media.ignix.social/editor/bin/2/source/ffmpeg-7.1.2.tar.xz
   and from https://ffmpeg.org/releases/ffmpeg-7.1.2.tar.xz.
   FFmpeg is a separate program: Ignix Editor runs it as its own process and
@@ -56,3 +58,35 @@ whisper.cpp v1.7.6 (whisper-cli) — https://github.com/ggml-org/whisper.cpp
 
 Whisper models (ggml-*.bin) are downloaded from
 https://huggingface.co/ggerganov/whisper.cpp under the MIT license.
+
+Analysis runtime and models (downloaded the first time `ignix-editor serve`, `faces`
+or another analysis command needs them, from https://media.ignix.social/editor/analysis,
+each checked against its SHA-256; listed in src/binaries.json):
+
+ONNX Runtime 1.23.2 (onnxruntime-node and onnxruntime-common, from npm) —
+  https://github.com/microsoft/onnxruntime — MIT License, Copyright (c) Microsoft
+  Corporation. Repackaged per platform without changes by
+  scripts/build-analysis-runtime.mjs; each package carries its LICENSE and
+  ThirdPartyNotices.txt (licenses/onnxruntime-MIT.txt here).
+
+YOLOX-S (person detector, ONNX export from OpenCV Zoo,
+  opencv/object_detection_yolox@78c368f) — Apache License 2.0, Copyright (c)
+  Megvii Inc.
+
+YuNet (face detector, face_detection_yunet_2023mar.onnx from OpenCV Zoo,
+  opencv/face_detection_yunet@3cc26e7) — MIT License, Copyright (c) 2020 Shiqi Yu
+  (licenses/yunet-MIT.txt).
+
+PP-OCRv3 text detector (ONNX from OpenCV Zoo, opencv/text_detection_ppocr@c299e81)
+  — Apache License 2.0, Copyright (c) PaddlePaddle Authors.
+
+CLIP ViT-B/32 (openai/clip-vit-base-patch32; ONNX export and tokenizer files from
+  Xenova/clip-vit-base-patch32@d15189d) — MIT License, Copyright (c) 2021 OpenAI.
+  The vision model is stored in two parts that Ignix Editor joins and checks.
+
+Inter (font, from @fontsource/inter) — SIL Open Font License 1.1, Copyright (c) 2016
+  The Inter Project Authors. Copied into the projects Ignix Creator's templates render
+  (src/creator), unmodified.
+
+Ignix Creator's composition templates (src/creator) were ported from Ignix Creator's own
+  code (Copyright (c) 2026 Ignix); no Remotion code is included.

package/README.md

@@ -8,15 +8,16 @@ npx @ignix-social/editor init my-reel  # creates ~/ignix-videos/my-reel
 npx @ignix-social/editor render ~/ignix-videos/my-reel
 ```
 
-Commands: `doctor`, `init`, `check`, `snapshot`, `render`, `preview`, `transcribe`, `ffmpeg`, `ffprobe`, `skills add`, `help`.
+Commands: `doctor`, `init`, `check`, `snapshot`, `render`, `preview`, `transcribe`, `faces`, `ffmpeg`, `ffprobe`, `skills add`, `fetch`, `serve`, `creator-job`, `help`.
 
 - Everything runs locally; your footage never leaves your machine.
 - ffmpeg (GPL build, without libx264) and whisper.cpp are downloaded once per machine into `~/.ignix-editor`, checked against their SHA-256. Chrome for rendering is downloaded once from Google's official channel.
 - No telemetry and no automatic updates: the version you install is the version that runs.
 - The final audio is normalised to −14 LUFS.
+- Analysis (`faces`, and `serve`, the local service Ignix Creator talks to: shots, people, faces, burned-in text, voice clean-up, transcription) runs on ONNX Runtime with open models (YOLOX, YuNet, PP-OCR, CLIP), downloaded the first time they are needed and checked against their SHA-256.
 - `ignix-editor skills add` installs the `ignix-editor` skill for Claude.
 
-Requires Node.js 22 or newer. macOS first; Windows next.
+Requires Node.js 22 or newer. Runs on macOS (Intel and Apple Silicon) and Windows 10/11 (x64).
 
 ## License
 

package/licenses/onnxruntime-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/licenses/yunet-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Shiqi Yu <shiqi.yu@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ignix-social/editor",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "description": "Ignix Editor: render HTML video compositions (reels, edits, clips) on your own computer. Based on HyperFrames.",
   "license": "Apache-2.0",
   "type": "module",
@@ -27,6 +27,7 @@
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
+    "@fontsource/inter": "^5.3.0",
     "@fontsource/montserrat": "^5.3.0",
     "@hono/node-server": "^2.0.5",
     "@puppeteer/browsers": "^3.2.2",

package/patches/index.mjs

@@ -41,6 +41,44 @@ export const patches = [
         replacement: 'if (false) { // ignix-editor: sin comprobación ni instalación automática de versiones',
       }),
   },
+  {
+    id: 'mf-encoder',
+    // Windows sin libx264 (patentes) ni tarjeta gráfica con codificador: Media Foundation
+    // (h264_mf), el codificador del propio Windows, como VideoToolbox en el Mac. Va el
+    // ÚLTIMO de los de hardware: si hay NVIDIA, Intel o AMD, se prefieren.
+    apply: (dist) => {
+      replaceAnchor(dist, {
+        anchor: '  "qsv",\n  "amf"\n];',
+        replacement: '  "qsv",\n  "amf",\n  "mf" // ignix-editor: Media Foundation (Windows)\n];',
+      });
+      replaceAnchor(dist, {
+        anchor: '  amf: "h264_amf"\n};',
+        replacement: '  amf: "h264_amf",\n  mf: "h264_mf"\n};',
+      });
+      replaceAnchor(dist, {
+        anchor: '    case "amf":\n      return codec === "h264" ? "h264_amf" : "hevc_amf";\n',
+        replacement: '    case "amf":\n      return codec === "h264" ? "h264_amf" : "hevc_amf";\n    case "mf":\n      return codec === "h264" ? "h264_mf" : "hevc_mf";\n',
+      });
+      // Calidad por bitrate, con la misma cuenta que VideoToolbox (sin -allow_sw, que es solo de Apple).
+      replaceAnchor(dist, {
+        anchor: '        case "amf":\n          if (bitrate) args.push("-b:v", bitrate);\n          else args.push("-rc", "cqp", "-qp_i", String(quality), "-qp_p", String(quality));\n          break;\n',
+        replacement:
+          '        case "amf":\n          if (bitrate) args.push("-b:v", bitrate);\n          else args.push("-rc", "cqp", "-qp_i", String(quality), "-qp_p", String(quality));\n          break;\n' +
+          '        case "mf": {\n          const vt = buildVideoToolboxRateControlArgs({ bitrate, width: options.width, height: options.height, fps: fpsToNumber(fps), quality });\n          args.push("-b:v", vt[1], "-rate_control", "u_vbr");\n          break;\n        }\n',
+        expect: 2,
+      });
+      // El aviso decía VideoToolbox también en Windows.
+      replaceAnchor(dist, {
+        anchor: 'FFmpeg does not include libx264; falling back to VideoToolbox H.264 encoding.',
+        replacement: "FFmpeg does not include libx264; using the system's hardware H.264 encoder (VideoToolbox on macOS, Media Foundation on Windows).",
+      });
+      // Un ffmpeg sin libx264 pero con h264_mf también sirve (antes: solo VideoToolbox).
+      replaceAnchor(dist, {
+        anchor: 'if (/\\bh264_videotoolbox\\b/.test(ffmpegEncodersOutput)) return "gpu";',
+        replacement: 'if (/\\bh264_(videotoolbox|mf)\\b/.test(ffmpegEncodersOutput)) return "gpu";',
+      });
+    },
+  },
   {
     id: 'no-desktop-promo',
     // Sin publicidad de la app de escritorio de HeyGen al terminar un render.

package/scripts/build-analysis-runtime.mjs

@@ -0,0 +1,45 @@
+// Monta los paquetes de onnxruntime por sistema para el análisis (ADR-0023 E1) a partir de los
+// paquetes oficiales de npm, sin compilar nada: un zip por plataforma con solo SU binario
+// (el paquete completo trae los seis sistemas, ~250 MB).
+//
+//   node scripts/build-analysis-runtime.mjs <dir-con-onnxruntime-node-y-common> <salida>
+//
+// <dir> contiene `onnxruntime-node-<v>.tgz` y `onnxruntime-common-<v>.tgz` (npm pack), además de
+// LICENSE y ThirdPartyNotices.txt del repositorio de ONNX Runtime en esa versión (MIT).
+// Imprime tamaño y sha256 de cada zip para src/binaries.json → analysis.runtime.
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import AdmZip from 'adm-zip';
+
+const [src, out] = process.argv.slice(2);
+if (!src || !out) throw new Error('usage: build-analysis-runtime.mjs <src> <out>');
+const VERSION = '1.23.2';
+const PLATFORMS = { 'darwin-x64': ['darwin', 'x64'], 'darwin-arm64': ['darwin', 'arm64'], 'win32-x64': ['win32', 'x64'] };
+
+const tmp = mkdtempSync(join(tmpdir(), 'ort-runtime-'));
+const unpack = (tgz, dest) => {
+  mkdirSync(dest, { recursive: true });
+  const r = spawnSync('tar', ['xzf', join(src, tgz), '-C', dest, '--strip-components=1']);
+  if (r.status !== 0) throw new Error(`tar ${tgz}: ${r.stderr}`);
+};
+unpack(`onnxruntime-node-${VERSION}.tgz`, join(tmp, 'node'));
+unpack(`onnxruntime-common-${VERSION}.tgz`, join(tmp, 'common'));
+mkdirSync(out, { recursive: true });
+for (const [name, [os, arch]] of Object.entries(PLATFORMS)) {
+  const stage = join(tmp, name, 'onnxruntime-node');
+  for (const f of ['package.json', 'dist']) cpSync(join(tmp, 'node', f), join(stage, f), { recursive: true });
+  cpSync(join(tmp, 'node', 'bin', 'napi-v6', os, arch), join(stage, 'bin', 'napi-v6', os, arch), { recursive: true });
+  cpSync(join(tmp, 'common'), join(stage, 'node_modules', 'onnxruntime-common'), { recursive: true });
+  cpSync(join(src, 'LICENSE'), join(stage, 'LICENSE'));
+  cpSync(join(src, 'ThirdPartyNotices.txt'), join(stage, 'ThirdPartyNotices.txt'));
+  const zip = new AdmZip();
+  zip.addLocalFolder(join(tmp, name));
+  const file = join(out, `onnxruntime-${VERSION}-${name}.zip`);
+  zip.writeZip(file);
+  const sha = createHash('sha256').update(readFileSync(file)).digest('hex');
+  console.log(JSON.stringify({ platform: name, file: `onnxruntime-${VERSION}-${name}.zip`, size: statSync(file).size, sha256: sha }));
+}
+rmSync(tmp, { recursive: true, force: true });

package/scripts/build-ffmpeg-windows.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+# Compila ffmpeg.exe + ffprobe.exe para Windows x64 desde Linux (MinGW-w64), con las mismas
+# reglas que en el Mac: GPL sin libx264 ni non-free y sin buscar librerías por su cuenta.
+# Codifica con Media Foundation (h264_mf), el codificador del propio Windows; si el PC tiene
+# NVIDIA/Intel/AMD el motor no los usa con este binario (no se compilan sus SDK).
+# Requiere: mingw-w64, nasm, make, curl (en Ubuntu: apt-get install mingw-w64 nasm make curl).
+# Uso: scripts/build-ffmpeg-windows.sh [dir-de-trabajo]  → <dir>/out/{ffmpeg.exe,ffprobe.exe}
+set -eu
+FFMPEG_VERSION=7.1.2
+ZLIB_VERSION=1.3.1
+WORK=${1:-"$HOME/ignix-editor-build/ffmpeg-windows-x64"}
+JOBS=$(nproc 2>/dev/null || sysctl -n hw.ncpu)
+HOST=x86_64-w64-mingw32
+mkdir -p "$WORK" && cd "$WORK"
+PREFIX="$WORK/deps"
+
+# zlib estática (PNG la necesita: el motor extrae y compone fotogramas en PNG)
+if [ ! -f "$PREFIX/lib/libz.a" ]; then
+  curl -sfL "https://zlib.net/fossils/zlib-$ZLIB_VERSION.tar.gz" -o zlib.tar.gz
+  tar xf zlib.tar.gz && cd "zlib-$ZLIB_VERSION"
+  make -f win32/Makefile.gcc PREFIX="$HOST-" -j"$JOBS" libz.a >/dev/null
+  mkdir -p "$PREFIX/lib" "$PREFIX/include"
+  cp libz.a "$PREFIX/lib/" && cp zlib.h zconf.h "$PREFIX/include/"
+  cd "$WORK"
+fi
+
+[ -d "ffmpeg-$FFMPEG_VERSION" ] || { curl -sfL "https://ffmpeg.org/releases/ffmpeg-$FFMPEG_VERSION.tar.xz" -o ffmpeg.tar.xz && tar xf ffmpeg.tar.xz; }
+cd "ffmpeg-$FFMPEG_VERSION"
+./configure \
+  --prefix="$WORK/out-prefix" \
+  --target-os=mingw32 --arch=x86_64 --cross-prefix="$HOST-" \
+  --enable-gpl --disable-nonfree --disable-version3 \
+  --disable-autodetect \
+  --disable-debug --disable-doc --disable-ffplay \
+  --disable-indevs --enable-indev=lavfi --disable-outdevs \
+  --disable-shared --enable-static \
+  --enable-w32threads --enable-mediafoundation \
+  --enable-zlib --disable-bzlib --disable-iconv \
+  --pkg-config=false \
+  --extra-cflags="-I$PREFIX/include" --extra-ldflags="-L$PREFIX/lib -static" >/dev/null
+make -j"$JOBS" >/dev/null
+mkdir -p "$WORK/out" && cp ffmpeg.exe ffprobe.exe "$WORK/out/"
+"$HOST-objdump" -p "$WORK/out/ffmpeg.exe" | grep "DLL Name" | sort -u
+echo "LISTO: $WORK/out"

package/src/analysis/clip.mjs

@@ -0,0 +1,142 @@
+// CLIP ViT-B/32 (MIT; el mismo modelo que usaba Creator) en onnxruntime: imágenes y frases en
+// el mismo espacio, para elegir el plano que enseña lo que dice la voz. Coseno imagen↔texto:
+// ≈0,18 sin relación, ≈0,3 cuando la imagen lo muestra.
+import { readFileSync } from 'node:fs';
+import { resizeBicubic, toCHW } from './image.mjs';
+import { ensureModel, loadOrt, session } from './runtime.mjs';
+
+const MEAN = [0.48145466, 0.4578275, 0.40821073];
+const STD = [0.26862954, 0.26130258, 0.27577711];
+const SOT = 49406;
+const EOT = 49407;
+const MAX_TOKENS = 77;
+
+// ── Tokenizador BPE de CLIP (bytes → unicode, fusiones por rango, «</w>» al final de palabra)
+let tok = null;
+async function tokenizer(log) {
+  if (tok) return tok;
+  const vocab = JSON.parse(readFileSync(await ensureModel('clip_vocab', log), 'utf8'));
+  const lines = readFileSync(await ensureModel('clip_merges', log), 'utf8').split('\n');
+  const ranks = new Map();
+  lines.slice(1).forEach((l, i) => {
+    if (l.trim()) ranks.set(l.trim(), i);
+  });
+  const byteMap = bytesToUnicode();
+  const cache = new Map();
+  const bpe = (token) => {
+    if (cache.has(token)) return cache.get(token);
+    let word = [...token.slice(0, -1), token.slice(-1) + '</w>'];
+    if (token.length === 1) word = [token + '</w>'];
+    for (;;) {
+      let best = null;
+      let bestRank = Infinity;
+      for (let i = 0; i < word.length - 1; i++) {
+        const r = ranks.get(`${word[i]} ${word[i + 1]}`);
+        if (r !== undefined && r < bestRank) {
+          bestRank = r;
+          best = i;
+        }
+      }
+      if (best === null) break;
+      const a = word[best];
+      const b = word[best + 1];
+      const merged = [];
+      for (let i = 0; i < word.length; i++) {
+        if (i < word.length - 1 && word[i] === a && word[i + 1] === b) {
+          merged.push(a + b);
+          i++;
+        } else merged.push(word[i]);
+      }
+      word = merged;
+    }
+    cache.set(token, word);
+    return word;
+  };
+  const PAT = /<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+/gu;
+  tok = (text) => {
+    const clean = text.normalize('NFC').replace(/\s+/g, ' ').trim().toLowerCase();
+    const ids = [SOT];
+    for (const m of clean.matchAll(PAT)) {
+      const mapped = [...Buffer.from(m[0], 'utf8')].map((b) => byteMap[b]).join('');
+      for (const piece of bpe(mapped)) {
+        const id = vocab[piece];
+        if (id !== undefined) ids.push(id);
+      }
+    }
+    return [...ids.slice(0, MAX_TOKENS - 1), EOT];
+  };
+  return tok;
+}
+
+function bytesToUnicode() {
+  const bs = [];
+  for (let b = 33; b <= 126; b++) bs.push(b);
+  for (let b = 161; b <= 172; b++) bs.push(b);
+  for (let b = 174; b <= 255; b++) bs.push(b);
+  const cs = [...bs];
+  let n = 0;
+  for (let b = 0; b < 256; b++) {
+    if (!bs.includes(b)) {
+      bs.push(b);
+      cs.push(256 + n);
+      n++;
+    }
+  }
+  const map = {};
+  bs.forEach((b, i) => (map[b] = String.fromCodePoint(cs[i])));
+  return map;
+}
+
+const unit = (v) => {
+  let s = 0;
+  for (const x of v) s += x * x;
+  const n = Math.sqrt(s) || 1;
+  return Float32Array.from(v, (x) => x / n);
+};
+
+/** Vectores unitarios (512) de cada frase. */
+export async function embedTexts(texts, log) {
+  const t = await tokenizer(log);
+  const s = await session('clip_text', log);
+  const { Tensor } = await loadOrt(log);
+  const out = [];
+  for (const text of texts) {
+    const ids = t(text);
+    const res = await s.run({ input_ids: new Tensor('int64', BigInt64Array.from(ids.map(BigInt)), [1, ids.length]) });
+    out.push(unit(res.text_embeds.data));
+  }
+  return out;
+}
+
+/** Vector unitario de una imagen (RGB intercalado w×h), preparada como CLIP. */
+export async function embedImage(frame, log) {
+  const s = await session('clip_vision', log);
+  const { Tensor } = await loadOrt(log);
+  // Lado corto a 224 (bicúbico, como PIL) y recorte central de 224×224.
+  const k = 224 / Math.min(frame.w, frame.h);
+  const W = Math.max(224, Math.round(frame.w * k));
+  const H = Math.max(224, Math.round(frame.h * k));
+  const big = resizeBicubic(frame.rgb, frame.w, frame.h, W, H);
+  const x0 = Math.floor((W - 224) / 2);
+  const y0 = Math.floor((H - 224) / 2);
+  const crop = new Uint8Array(224 * 224 * 3);
+  for (let y = 0; y < 224; y++) crop.set(big.subarray(((y0 + y) * W + x0) * 3, ((y0 + y) * W + x0 + 224) * 3), y * 224 * 3);
+  const input = new Tensor('float32', toCHW(crop, 224, 224, { scale: 1 / 255, mean: MEAN, std: STD }), [1, 3, 224, 224]);
+  const res = await s.run({ pixel_values: input });
+  return unit(res.image_embeds.data);
+}
+
+export const dot = (a, b) => {
+  let s = 0;
+  for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+  return s;
+};
+
+/** Media de varios vectores, unitaria (un plano = sus fotogramas juntos). */
+export function pool(vecs) {
+  const out = new Float32Array(vecs[0].length);
+  for (const v of vecs) for (let i = 0; i < v.length; i++) out[i] += v[i];
+  return unit(out);
+}
+
+export { tokenizer as clipTokenizer };

package/src/analysis/detect.mjs

@@ -0,0 +1,185 @@
+// Detectores sobre onnxruntime, iguales en Mac y en Windows:
+//  · personas por el CUERPO (YOLOX-S, Apache-2.0): alguien que mira abajo o de espaldas sigue
+//    siendo alguien. El mismo detector que usa el trabajador del recast en la nube, para que los
+//    dos lados cuenten las mismas personas.
+//  · caras (YuNet, MIT) con sus cinco puntos (ojos, nariz, boca): sirven para encuadrar y para
+//    saber si una cara se ve de FRENTE (el parecido de un recast depende de eso).
+//  · texto quemado (detector de PP-OCRv3, Apache-2.0): letras sobre la persona salen
+//    garabateadas en un recast.
+// Todas las cajas salen normalizadas (0..1) respecto al fotograma.
+import { letterbox, nms, resize, toCHW } from './image.mjs';
+import { session } from './runtime.mjs';
+
+const S = 640;
+
+// ── YOLOX
+const ANCHORS = (() => {
+  const g = [];
+  for (const st of [8, 16, 32]) {
+    const n = S / st;
+    for (let y = 0; y < n; y++) for (let x = 0; x < n; x++) g.push([x, y, st]);
+  }
+  return g;
+})();
+export const PERSON_MIN_SCORE = 0.4;
+
+/** Salida cruda de YOLOX (8400 × 85) → cajas de persona en píxeles del fotograma. */
+export function decodeYolox(out, ratio, width, height, minScore = PERSON_MIN_SCORE) {
+  const found = [];
+  for (let i = 0; i < ANCHORS.length; i++) {
+    const o = i * 85;
+    const score = out[o + 4] * out[o + 5]; // un objeto, y ese objeto es una persona
+    if (score < minScore) continue;
+    const [gx, gy, st] = ANCHORS[i];
+    const cx = (out[o] + gx) * st;
+    const cy = (out[o + 1] + gy) * st;
+    const w = Math.exp(out[o + 2]) * st;
+    const h = Math.exp(out[o + 3]) * st;
+    const x0 = Math.max(0, (cx - w / 2) / ratio);
+    const y0 = Math.max(0, (cy - h / 2) / ratio);
+    const x1 = Math.min(width, (cx + w / 2) / ratio);
+    const y1 = Math.min(height, (cy + h / 2) / ratio);
+    if (x1 > x0 && y1 > y0) found.push({ x: x0, y: y0, w: x1 - x0, h: y1 - y0, score });
+  }
+  return nms(found, 0.5);
+}
+
+export async function people(frame, log) {
+  const s = await session('yolox', log);
+  const { rgb, r } = letterbox(frame.rgb, frame.w, frame.h, S, 114);
+  const input = new (await tensorClass(log))('float32', toCHW(rgb, S, S), [1, 3, S, S]);
+  const res = await s.run({ [s.inputNames[0]]: input });
+  const out = res[s.outputNames[0]].data;
+  return decodeYolox(out, r, frame.w, frame.h).map((b) => norm(b, frame));
+}
+
+// ── YuNet
+export const FACE_MIN_SCORE = 0.7;
+
+/** Salidas de YuNet → caras {x,y,w,h,score,kps:[[x,y]×5]} en píxeles del fotograma. */
+export function decodeYunet(out, ratio, width, height, minScore = FACE_MIN_SCORE) {
+  const found = [];
+  for (const st of [8, 16, 32]) {
+    const cls = out[`cls_${st}`];
+    const obj = out[`obj_${st}`];
+    const box = out[`bbox_${st}`];
+    const kps = out[`kps_${st}`];
+    const cols = S / st;
+    for (let i = 0; i < cls.length; i++) {
+      const score = Math.sqrt(Math.min(1, Math.max(0, cls[i])) * Math.min(1, Math.max(0, obj[i])));
+      if (score < minScore) continue;
+      const c = i % cols;
+      const r = Math.floor(i / cols);
+      const cx = (c + box[i * 4]) * st;
+      const cy = (r + box[i * 4 + 1]) * st;
+      const w = Math.exp(box[i * 4 + 2]) * st;
+      const h = Math.exp(box[i * 4 + 3]) * st;
+      const pts = [];
+      for (let k = 0; k < 5; k++) pts.push([((kps[i * 10 + 2 * k] + c) * st) / ratio, ((kps[i * 10 + 2 * k + 1] + r) * st) / ratio]);
+      const x0 = Math.max(0, (cx - w / 2) / ratio);
+      const y0 = Math.max(0, (cy - h / 2) / ratio);
+      const x1 = Math.min(width, (cx + w / 2) / ratio);
+      const y1 = Math.min(height, (cy + h / 2) / ratio);
+      if (x1 > x0 && y1 > y0) found.push({ x: x0, y: y0, w: x1 - x0, h: y1 - y0, score, kps: pts });
+    }
+  }
+  return nms(found, 0.3);
+}
+
+/**
+ * ¿Se ve la cara de frente? Con los cinco puntos de YuNet: la nariz cae entre los dos ojos y a
+ * la misma distancia de cada uno, y los ojos no están demasiado juntos para el tamaño de la cara
+ * (de perfil se juntan). Umbrales medidos con los clips del recast (ADR-0023 E1).
+ */
+export function isFrontal(face, { maxSkew = FRONTAL_MAX_SKEW, minEyes = FRONTAL_MIN_EYES } = {}) {
+  const [re, le, nose] = face.kps;
+  const eyes = Math.hypot(le[0] - re[0], le[1] - re[1]);
+  if (eyes < minEyes * face.w) return false;
+  const dl = Math.hypot(nose[0] - le[0], nose[1] - le[1]);
+  const dr = Math.hypot(nose[0] - re[0], nose[1] - re[1]);
+  return Math.abs(dl - dr) / (dl + dr) <= maxSkew;
+}
+// Medido (2026-10-06) con seis clips del recast: buenos 83–94 % de muestras de frente,
+// malos 14–37 %; con los umbrales de Creator (≥50 %, ≥110 px) separan igual que el Haar de antes.
+export const FRONTAL_MAX_SKEW = 0.2;
+export const FRONTAL_MIN_EYES = 0.3;
+
+export async function faces(frame, log) {
+  const s = await session('yunet', log);
+  // YuNet espera BGR en 0..255 (como lo prepara OpenCV), en un cuadrado de 640.
+  const { rgb, r } = letterbox(frame.rgb, frame.w, frame.h, S, 0);
+  const input = new (await tensorClass(log))('float32', toCHW(rgb, S, S, { bgr: true }), [1, 3, S, S]);
+  const res = await s.run({ [s.inputNames[0]]: input });
+  const out = Object.fromEntries(s.outputNames.map((n) => [n, res[n].data]));
+  return decodeYunet(out, r, frame.w, frame.h).map((f) => ({
+    ...norm(f, frame),
+    frontal: isFrontal(f),
+    kps: f.kps.map(([x, y]) => [x / frame.w, y / frame.h]),
+    // Tamaño de la cara en píxeles del ORIGINAL, no del fotograma de trabajo.
+    px: f.h * (frame.scale ?? 1),
+  }));
+}
+
+// ── PP-OCR (detector de texto DB)
+const OCR_MEAN = [123.675, 116.28, 103.53];
+const OCR_STD = [0.229, 0.224, 0.225];
+
+/** Mapa de probabilidad del detector DB → cajas de texto en coordenadas del mapa. */
+export function decodeDb(prob, W, H, { bin = 0.3, minScore = 0.5, unclip = 2.0, max = 200 } = {}) {
+  const seen = new Uint8Array(W * H);
+  const boxes = [];
+  const stack = [];
+  for (let start = 0; start < W * H && boxes.length < max; start++) {
+    if (seen[start] || prob[start] < bin) continue;
+    // Componente conexa (4 vecinos) de píxeles sobre el umbral.
+    let x0 = W, y0 = H, x1 = 0, y1 = 0, sum = 0, n = 0;
+    stack.push(start);
+    seen[start] = 1;
+    while (stack.length) {
+      const p = stack.pop();
+      const x = p % W;
+      const y = (p - x) / W;
+      sum += prob[p];
+      n += 1;
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+      for (const q of [x > 0 ? p - 1 : -1, x < W - 1 ? p + 1 : -1, y > 0 ? p - W : -1, y < H - 1 ? p + W : -1]) {
+        if (q >= 0 && !seen[q] && prob[q] >= bin) {
+          seen[q] = 1;
+          stack.push(q);
+        }
+      }
+    }
+    const w = x1 - x0 + 1;
+    const h = y1 - y0 + 1;
+    if (Math.min(w, h) < 3 || sum / n < minScore) continue;
+    // El detector DB «encoge» el texto: se agranda la caja en área·ratio/perímetro.
+    const d = (w * h * unclip) / (2 * (w + h));
+    boxes.push({ x: Math.max(0, x0 - d), y: Math.max(0, y0 - d), w: Math.min(W, x1 + 1 + d) - Math.max(0, x0 - d), h: Math.min(H, y1 + 1 + d) - Math.max(0, y0 - d), score: sum / n });
+  }
+  return boxes;
+}
+
+export async function text(frame, log) {
+  const s = await session('ppocr', log);
+  const [W, H] = frame.h > frame.w ? [416, 736] : [736, 416];
+  const small = resize(frame.rgb, frame.w, frame.h, W, H);
+  // Como lo prepara OpenCV para este modelo: canales en orden BGR, medias y escalas por posición.
+  const input = new (await tensorClass(log))('float32', toCHW(small, W, H, { bgr: true, mean: OCR_MEAN, std: OCR_STD.map((v) => v * 255) }), [1, 3, H, W]);
+  const res = await s.run({ [s.inputNames[0]]: input });
+  const prob = res[s.outputNames[0]].data;
+  return decodeDb(prob, W, H)
+    .slice(0, 40)
+    .map((b) => ({ x: b.x / W, y: b.y / H, w: Math.min(1, b.w / W), h: Math.min(1, b.h / H) }));
+}
+
+// ── utilidades
+const norm = (b, frame) => ({ x: b.x / frame.w, y: b.y / frame.h, w: b.w / frame.w, h: b.h / frame.h, score: +b.score.toFixed(3) });
+
+let Tensor = null;
+async function tensorClass(log) {
+  if (!Tensor) Tensor = (await import('./runtime.mjs').then((m) => m.loadOrt(log))).Tensor;
+  return Tensor;
+}