@ignix-social/editor 0.1.5 → 0.1.7

package/src/creator/fit.mjs

@@ -0,0 +1,58 @@
+// Ajuste de textos de las plantillas de Creator con las medidas REALES de la fuente (Inter),
+// al generar el proyecto (en Node): el dibujante nunca mide la página. Mismas reglas que en
+// Creator: el tamaño más grande (de `max` hacia abajo, de 4 en 4) cuyas líneas caben en `width`
+// y en `maxLines`; si no, el mínimo tal cual.
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import * as fontkit from 'fontkit';
+
+const require = createRequire(import.meta.url);
+export const INTER_DIR = join(dirname(require.resolve('@fontsource/inter/package.json')), 'files');
+
+// Las mismas caras que cargaba Creator: 400, 600 y 800 (y latin-ext 400 y 800). Un 700 o un 900
+// se dibuja con la 800 (la más cercana por encima que hay), así que se mide con ella.
+export const INTER_FACES = [
+  { weight: 400, file: 'inter-latin-400-normal.woff2' },
+  { weight: 600, file: 'inter-latin-600-normal.woff2' },
+  { weight: 800, file: 'inter-latin-800-normal.woff2' },
+  { weight: 400, file: 'inter-latin-ext-400-normal.woff2', range: 'U+0100-024F' },
+  { weight: 800, file: 'inter-latin-ext-800-normal.woff2', range: 'U+0100-024F' },
+];
+
+const fonts = new Map();
+function fontFor(weight) {
+  const w = Number(weight) >= 700 ? 800 : Number(weight) >= 600 ? 600 : 400;
+  if (!fonts.has(w)) fonts.set(w, fontkit.openSync(join(INTER_DIR, `inter-latin-${w}-normal.woff2`)));
+  return fonts.get(w);
+}
+
+/** Ancho en px de `text` a `size` px, con el espaciado de letras de las plantillas (−0,02 em). */
+export function measure(text, size, weight, letterSpacingEm = -0.02) {
+  const f = fontFor(weight);
+  const run = f.layout(text);
+  return (run.advanceWidth / f.unitsPerEm) * size + letterSpacingEm * size * [...text].length;
+}
+
+export function fitLines(text, { width, max, min, maxLines, weight }) {
+  const words = String(text).split(/\s+/).filter(Boolean);
+  for (let size = max; size >= min; size -= 4) {
+    const lines = [];
+    let current = '';
+    let ok = true;
+    for (const word of words) {
+      if (measure(word, size, weight) > width) {
+        ok = false;
+        break;
+      }
+      const next = current ? `${current} ${word}` : word;
+      if (measure(next, size, weight) <= width) current = next;
+      else {
+        lines.push(current);
+        current = word;
+      }
+    }
+    if (current) lines.push(current);
+    if (ok && lines.length <= maxLines) return { size, lines };
+  }
+  return { size: min, lines: [text] };
+}

package/src/creator/job.mjs

@@ -0,0 +1,163 @@
+// `ignix-editor creator-job --job <dir> [--browser <abs>] [--workers N]`: el proceso de render de
+// Ignix Creator (ADR-0023 E2), con el mismo contrato que su motor anterior, para que Creator solo
+// cambie qué lanza:
+//
+//   <dir>/inputs.json        { assetRef: { file, kind, w?, h? } }, ficheros DENTRO de <dir>
+//   <dir>/composition.json   la composición (CompositionSpec ya validado por Creator), o
+//   <dir>/thumbnails.json    { count, native } para fotogramas de referencia
+//   → <dir>/video.mp4 (composición) o <dir>/t<n>_<k>.jpg (miniaturas)
+//
+// Informa por stdout con líneas JSON cerradas: progress {stage, fraction}, verified
+// {durationSec, width, height, audio}, output {file}, done, error {code}. SIGTERM, o perder
+// el proceso padre, cancela.
+import { spawnSync } from 'node:child_process';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { basename, isAbsolute, join, relative } from 'node:path';
+import { HOME, ensureTool } from '../binaries.mjs';
+import { renderProject } from '../engine.mjs';
+import { probe } from '../analysis/media.mjs';
+import { buildProject } from './build.mjs';
+
+const INPUT_NAME = /^m\d{1,3}\.(png|jpg|webp|mp4|mov|webm|m4a|mp3|wav)$/;
+const ASSET = /^asset_[A-Za-z0-9]{12,40}$/;
+const emit = (e) => process.stdout.write(`${JSON.stringify(e)}\n`);
+class JobError extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+}
+const fail = (code) => {
+  throw new JobError(code);
+};
+
+function readJson(file, max) {
+  let st;
+  try {
+    st = lstatSync(file);
+  } catch {
+    return fail('invalid_job');
+  }
+  if (!st.isFile() || st.size > max) fail('invalid_job');
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return fail('invalid_job');
+  }
+}
+
+function readInputs(job) {
+  const raw = readJson(join(job, 'inputs.json'), 100_000);
+  if (!raw || typeof raw !== 'object' || Object.keys(raw).length > 40) fail('invalid_job');
+  const out = {};
+  for (const [ref, v] of Object.entries(raw)) {
+    if (!ASSET.test(ref) || !v || !INPUT_NAME.test(v.file) || !['image', 'video', 'audio'].includes(v.kind)) fail('invalid_job');
+    const path = join(job, v.file);
+    if (relative(job, path) !== basename(path)) fail('invalid_job');
+    if (!existsSync(path) || !lstatSync(path).isFile()) fail('missing_input');
+    out[ref] = { ...v, path };
+  }
+  return out;
+}
+
+/** Fotogramas de referencia: en un marco vertical fijo, o con la forma del original (lado mayor 1280). */
+async function thumbnails(job, inputs, signal) {
+  const spec = readJson(join(job, 'thumbnails.json'), 10_000);
+  const count = Number(spec.count);
+  if (!Number.isInteger(count) || count < 1 || count > 6) fail('invalid_job');
+  const native = spec.native === true;
+  const ffmpeg = await ensureTool('ffmpeg');
+  const ffprobe = await ensureTool('ffprobe');
+  emit({ t: 'progress', stage: 'preparing', fraction: 0 });
+  const visual = Object.values(inputs)
+    .filter((i) => i.kind !== 'audio')
+    .sort((x, y) => x.file.localeCompare(y.file, 'en', { numeric: true }))
+    .slice(0, 6);
+  const total = visual.reduce((n, i) => n + (i.kind === 'video' ? count : 1), 0);
+  let made = 0;
+  for (const [n, input] of visual.entries()) {
+    const info = probe(ffprobe, input.path);
+    const times = input.kind === 'video' ? Array.from({ length: count }, (_, k) => ((k + 0.5) * Math.max(0.1, info.duration)) / count) : [0];
+    const w0 = native ? (input.w ?? info.width) : 0;
+    const h0 = native ? (input.h ?? info.height) : 0;
+    const k = native ? Math.min(1, 1280 / Math.max(w0, h0)) : 0;
+    const even = (x) => Math.max(2, Math.round((x * k) / 2) * 2);
+    const vf = native && w0 && h0 ? `scale=${even(w0)}:${even(h0)}` : 'scale=540:960:force_original_aspect_ratio=decrease,pad=540:960:(ow-iw)/2:(oh-ih)/2:color=0x111111';
+    for (const [j, t] of times.entries()) {
+      if (signal.aborted) fail('cancelled');
+      const file = `t${n + 1}_${j}.jpg`;
+      const r = spawnSync(ffmpeg, ['-nostdin', '-loglevel', 'error', '-y', ...(input.kind === 'video' ? ['-ss', (Math.round(t * 100) / 100).toFixed(2)] : []), '-i', input.path, '-frames:v', '1', '-vf', vf, '-q:v', native ? '3' : '4', join(job, file)], { encoding: 'utf8' });
+      if (r.status !== 0) fail('render_failed');
+      emit({ t: 'output', file });
+      made += 1;
+      emit({ t: 'progress', stage: 'rendering', fraction: Math.min(0.99, made / total) });
+    }
+  }
+}
+
+async function composition(job, inputs, signal, browser, workers) {
+  const spec = readJson(join(job, 'composition.json'), 2_000_000);
+  if (!spec || !Array.isArray(spec.scenes) || typeof spec.format !== 'string') fail('invalid_job');
+  for (const ref of JSON.stringify(spec).match(/asset_[A-Za-z0-9]{12,40}/g) ?? []) if (!inputs[ref]) fail('missing_input');
+  emit({ t: 'progress', stage: 'preparing', fraction: 0 });
+  const ffmpeg = await ensureTool('ffmpeg');
+  const ffprobe = await ensureTool('ffprobe');
+  mkdirSync(join(HOME, 'work'), { recursive: true });
+  const dir = mkdtempSync(join(HOME, 'work', 'creator-'));
+  const out = join(job, 'video.partial.mp4');
+  try {
+    try {
+      buildProject({ spec, media: inputs, dir, ffmpeg, ffprobe });
+    } catch (e) {
+      process.stderr.write(`${e.stack ?? e}\n`);
+      fail(/missing input/.test(e.message) ? 'missing_input' : 'invalid_job');
+    }
+    try {
+      const engineArgs = workers ? ['--workers', String(workers)] : [];
+      await renderProject(dir, out, { onProgress: (p) => emit({ t: 'progress', ...p }), signal, browser, engineArgs });
+    } catch (e) {
+      if (signal.aborted) fail('cancelled');
+      process.stderr.write(`${e.stack ?? e}\n`);
+      fail(/browser|chrome/i.test(e.message) ? 'browser_failed' : 'render_failed');
+    }
+    // Comprobado antes de darlo por bueno: dura lo que debe, tiene imagen y el tamaño del formato.
+    const info = probe(ffprobe, out);
+    if (!info.hasVideo || info.duration <= 0) fail('verify_failed');
+    emit({ t: 'verified', durationSec: +info.duration.toFixed(3), width: info.width, height: info.height, audio: info.hasAudio });
+    renameSync(out, join(job, 'video.mp4'));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+    rmSync(out, { force: true });
+  }
+}
+
+export async function creatorJob(argv) {
+  const at = (k) => {
+    const i = argv.indexOf(k);
+    return i >= 0 ? argv[i + 1] : undefined;
+  };
+  const job = at('--job');
+  const browser = at('--browser');
+  const workers = at('--workers');
+  const ctrl = new AbortController();
+  const quit = () => ctrl.abort();
+  process.on('SIGTERM', quit);
+  process.on('SIGINT', quit);
+  const parent = process.ppid;
+  setInterval(() => process.ppid !== parent && quit(), 1000).unref();
+  try {
+    if (!job || !isAbsolute(job) || !existsSync(job)) fail('invalid_job');
+    if (browser && !isAbsolute(browser)) fail('invalid_job');
+    if (workers !== undefined && !/^([1-9]|1[0-6])$/.test(workers)) fail('invalid_job');
+    const inputs = readInputs(job);
+    if (existsSync(join(job, 'thumbnails.json'))) await thumbnails(job, inputs, ctrl.signal);
+    else await composition(job, inputs, ctrl.signal, browser, workers ? Number(workers) : null);
+    emit({ t: 'done' });
+    process.exit(0);
+  } catch (e) {
+    const code = e instanceof JobError ? e.code : ctrl.signal.aborted ? 'cancelled' : 'render_failed';
+    if (!(e instanceof JobError)) process.stderr.write(`${e?.stack ?? e}\n`);
+    emit({ t: 'error', code });
+    process.exit(code === 'cancelled' ? 2 : 1);
+  }
+}

package/src/creator/render.mjs

@@ -0,0 +1,22 @@
+// Renderizar una composición de Ignix Creator con Ignix Editor (ADR-0023 E2): se genera el
+// proyecto en una carpeta de trabajo, se renderiza y se borra la carpeta.
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { HOME, ensureTool } from '../binaries.mjs';
+import { renderProject } from '../engine.mjs';
+import { buildProject } from './build.mjs';
+import { mkdirSync } from 'node:fs';
+
+export async function renderComposition({ spec, media, out, keep = false, log = () => {} }) {
+  const ffmpeg = await ensureTool('ffmpeg', log);
+  const ffprobe = await ensureTool('ffprobe', log);
+  mkdirSync(join(HOME, 'work'), { recursive: true });
+  const dir = mkdtempSync(join(HOME, 'work', 'creator-'));
+  try {
+    const meta = buildProject({ spec, media, dir, ffmpeg, ffprobe });
+    const r = await renderProject(dir, out, { quiet: true, log });
+    return { ...meta, output: r.output, loudness: r.loudness, project: keep ? dir : null };
+  } finally {
+    if (!keep) rmSync(dir, { recursive: true, force: true });
+  }
+}