@ignix-social/editor 0.1.7 → 0.1.8

package/NOTICE

@@ -84,6 +84,13 @@ CLIP ViT-B/32 (openai/clip-vit-base-patch32; ONNX export and tokenizer files fro
   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.
 
+YAMNet (sound event classifier, Google's AudioSet model) as ported to PyTorch by
+  torch_audioset (w-hc/torch_audioset) — MIT License, Copyright (c) 2021 Haochen
+  (licenses/torch_audioset-MIT.txt); ONNX export by Qualcomm AI Hub (qualcomm/YamNet
+  v0.63.0, MIT). The AudioSet class names (src/analysis/audioset-classes.json) come from
+  tensorflow/models (research/audioset/yamnet/yamnet_class_map.csv) — Apache License 2.0,
+  Copyright The TensorFlow Authors.
+
 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.

package/licenses/torch_audioset-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Haochen
+
+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.7",
+  "version": "0.1.8",
   "description": "Ignix Editor: render HTML video compositions (reels, edits, clips) on your own computer. Based on HyperFrames.",
   "license": "Apache-2.0",
   "type": "module",

package/patches/index.mjs

@@ -1,6 +1,7 @@
 // Parches sobre el dist compilado de HyperFrames. Los nombres de fichero llevan hash y
 // cambian entre versiones, así que cada parche busca su ancla en TODO dist/ y exige que
 // aparezca exactamente las veces esperadas. Si no, la actualización se para aquí.
+import { createHash } from 'node:crypto';
 import { readFileSync, readdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
@@ -17,6 +18,20 @@ function replaceAnchor(dist, { anchor, replacement, expect = 1 }) {
   if (hits !== expect) throw new Error(`Ancla encontrada ${hits} veces (se esperaban ${expect}): ${anchor.slice(0, 80)}…`);
 }
 
+/** Sustituye TODAS las apariciones de `anchor` en dist/ y exige al menos `min`. */
+function replaceAll(dist, { anchor, replacement, min = 1 }) {
+  let hits = 0;
+  for (const f of readdirSync(dist).filter((n) => n.endsWith('.js'))) {
+    const file = join(dist, f);
+    const src = readFileSync(file, 'utf8');
+    const n = src.split(anchor).length - 1;
+    if (!n) continue;
+    hits += n;
+    writeFileSync(file, src.split(anchor).join(replacement));
+  }
+  if (hits < min) throw new Error(`Ancla encontrada ${hits} veces (se esperaban al menos ${min}): ${anchor.slice(0, 80)}…`);
+}
+
 export const patches = [
   {
     id: 'no-telemetry',
@@ -88,6 +103,20 @@ export const patches = [
         replacement: '  return null; // ignix-editor: sin aviso de la app de escritorio\n  if (ready && (installed ?? desktopInstalled({ platform, env })))',
       }),
   },
+  {
+    id: 'log-prefix',
+    // Lo que ve el cliente (y su agente) dice Ignix Editor: el motor firmaba sus mensajes con
+    // «[hyperframes]» y el agente acababa nombrando HyperFrames.
+    apply: (dist) => {
+      replaceAll(dist, { anchor: '[hyperframes]', replacement: '[ignix-editor]', min: 20 });
+      // El motor comprueba la huella de su runtime (hyperframe.manifest.json): se recalcula.
+      const mf = join(dist, 'hyperframe.manifest.json');
+      const manifest = JSON.parse(readFileSync(mf, 'utf8'));
+      const runtime = readFileSync(join(dist, manifest.artifacts.iife), 'utf8');
+      manifest.sha256 = createHash('sha256').update(runtime, 'utf8').digest('hex');
+      writeFileSync(mf, `${JSON.stringify(manifest, null, 2)}\n`);
+    },
+  },
   {
     id: 'chrome-first-launch',
     // Antes de renderizar, el motor pregunta `chrome --version` con 5 s de margen. La

package/skills/ignix-editor/SKILL.md

@@ -31,6 +31,7 @@ One project = one folder with `index.html` at its root and everything it uses in
 - `data-duration` (seconds) is the length of the video. Set it from the real voice: sum of the lines + air + a ~0.6 s tail.
 - Size the root with `width/height:100%`; the canvas size comes from `data-width/height`.
 - Exactly one timeline, registered by `IgnixFrame.run({ id, duration, fps }, render)` (section 2). `id` = `data-composition-id`.
+- Keep the two scripts `init` puts in `<head>`, in this order: `<script src="assets/gsap.min.js"></script>` then `<script src="ignix-frame.js"></script>`. If you rewrite `index.html`, copy them over: without GSAP first nothing moves (`check` reports `gsap_before_frame`).
 
 ### Media: written in the HTML, never created by JS
 
@@ -138,6 +139,8 @@ 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.
+
 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.

package/src/analysis/audio-events.mjs

@@ -0,0 +1,223 @@
+// Qué SUENA en un vídeo, por tramos de 0,96 s: voz, música, efectos (whoosh, pop, ding,
+// golpe…). YAMNet (Google, AudioSet: 521 clases), en el port a PyTorch de torch_audioset (MIT)
+// que Qualcomm publica en ONNX; las clases son las de AudioSet (yamnet_class_map.csv de
+// tensorflow/models, Apache-2.0). Para el estilo de edición (ADR-0023 E3): qué efectos usa
+// alguien y cuánta música lleva.
+//
+// La entrada del modelo es un parche de 96 × 64 del espectrograma log-mel, calculado como lo
+// hace YAMNet: 16 kHz mono, ventana de Hann periódica de 25 ms cada 10 ms, FFT de 512, 64
+// bandas mel (escala HTK) de 125 a 7500 Hz, log(mel + 0,001); parches de 0,96 s cada 0,48 s.
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { pcm } from './media.mjs';
+import { session } from './runtime.mjs';
+
+const RATE = 16000;
+const WIN = 400;
+const HOP = 160;
+const NFFT = 512;
+const BINS = NFFT / 2 + 1;
+const MELS = 64;
+const PATCH = 96;
+const PATCH_HOP = 48;
+export const PATCH_SEC = (PATCH * HOP) / RATE; // 0,96
+export const PATCH_HOP_SEC = (PATCH_HOP * HOP) / RATE; // 0,48
+
+export const CLASSES = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'audioset-classes.json'), 'utf8'));
+
+const hzToMel = (f) => 1127 * Math.log(1 + f / 700);
+
+/** Matriz de pesos lineal → mel como tf.signal.linear_to_mel_weight_matrix (sin la banda DC). */
+function melMatrix() {
+  const nyq = RATE / 2;
+  const lo = hzToMel(125);
+  const hi = hzToMel(7500);
+  const edges = Array.from({ length: MELS + 2 }, (_, i) => lo + ((hi - lo) * i) / (MELS + 1));
+  const w = Array.from({ length: BINS }, () => new Float32Array(MELS));
+  for (let b = 1; b < BINS; b++) {
+    const mel = hzToMel((nyq * b) / (BINS - 1));
+    for (let m = 0; m < MELS; m++) {
+      const lower = (mel - edges[m]) / (edges[m + 1] - edges[m]);
+      const upper = (edges[m + 2] - mel) / (edges[m + 2] - edges[m + 1]);
+      w[b][m] = Math.max(0, Math.min(lower, upper));
+    }
+  }
+  return w;
+}
+const MEL = melMatrix();
+const HANN = Float32Array.from({ length: WIN }, (_, n) => 0.5 - 0.5 * Math.cos((2 * Math.PI * n) / WIN));
+
+/** Magnitud de la FFT real de 512 puntos (radix 2, en el sitio). */
+function magnitude(frame, re, im) {
+  re.fill(0);
+  im.fill(0);
+  re.set(frame);
+  for (let i = 1, j = 0; i < NFFT; i++) {
+    let bit = NFFT >> 1;
+    for (; j & bit; bit >>= 1) j ^= bit;
+    j ^= bit;
+    if (i < j) {
+      [re[i], re[j]] = [re[j], re[i]];
+      [im[i], im[j]] = [im[j], im[i]];
+    }
+  }
+  for (let len = 2; len <= NFFT; len <<= 1) {
+    const ang = (-2 * Math.PI) / len;
+    for (let i = 0; i < NFFT; i += len) {
+      for (let k = 0; k < len / 2; k++) {
+        const cr = Math.cos(ang * k);
+        const ci = Math.sin(ang * k);
+        const a = i + k;
+        const b = a + len / 2;
+        const tr = re[b] * cr - im[b] * ci;
+        const ti = re[b] * ci + im[b] * cr;
+        re[b] = re[a] - tr;
+        im[b] = im[a] - ti;
+        re[a] += tr;
+        im[a] += ti;
+      }
+    }
+  }
+  const out = new Float32Array(BINS);
+  for (let k = 0; k < BINS; k++) out[k] = Math.hypot(re[k], im[k]);
+  return out;
+}
+
+/** Espectrograma log-mel (frames × 64) de muestras mono a 16 kHz. */
+export function logMel(samples) {
+  const frames = samples.length >= WIN ? 1 + Math.floor((samples.length - WIN) / HOP) : 0;
+  const out = new Float32Array(frames * MELS);
+  const buf = new Float32Array(WIN);
+  const re = new Float64Array(NFFT);
+  const im = new Float64Array(NFFT);
+  for (let f = 0; f < frames; f++) {
+    for (let n = 0; n < WIN; n++) buf[n] = samples[f * HOP + n] * HANN[n];
+    const mag = magnitude(buf, re, im);
+    for (let m = 0; m < MELS; m++) {
+      let s = 0;
+      for (let b = 1; b < BINS; b++) s += mag[b] * MEL[b][m];
+      out[f * MELS + m] = Math.log(s + 0.001);
+    }
+  }
+  return { frames, data: out };
+}
+
+const sigmoid = (x) => 1 / (1 + Math.exp(-x));
+
+/**
+ * Clasifica el sonido de un fichero por parches de 0,96 s (cada 0,48 s). Devuelve, por parche,
+ * su instante y las puntuaciones (0..1) de las 521 clases.
+ */
+export async function classify(ffmpeg, path, { maxSec = 600, log = () => {} } = {}) {
+  const chunks = [];
+  let total = 0;
+  const has = await pcm(ffmpeg, path, {
+    rate: RATE,
+    end: maxSec,
+    onSamples: (s) => {
+      chunks.push(Float32Array.from(s));
+      total += s.length;
+    },
+  });
+  if (has === false || !total) return [];
+  // Como YAMNet: con silencio hasta completar el último parche (un efecto de 0,3 s es un
+  // parche, no ninguno).
+  const need = (PATCH - 1) * HOP + WIN;
+  const len = total < need ? need : need + Math.ceil((total - need) / (PATCH_HOP * HOP)) * PATCH_HOP * HOP;
+  const samples = new Float32Array(len);
+  let o = 0;
+  for (const c of chunks) {
+    samples.set(c, o);
+    o += c.length;
+  }
+  const { frames, data } = logMel(samples);
+  const s = await session('yamnet', log);
+  const ort = await import('./runtime.mjs').then((m) => m.loadOrt(log));
+  const patches = [];
+  for (let start = 0; start + PATCH <= frames; start += PATCH_HOP) {
+    const input = new ort.Tensor('float32', data.slice(start * MELS, (start + PATCH) * MELS), [1, 1, PATCH, MELS]);
+    const res = await s.run({ [s.inputNames[0]]: input });
+    const raw = res[s.outputNames[0]].data;
+    // El port da logits; YAMNet da probabilidades. Se normaliza a 0..1 en los dos casos.
+    const logits = raw.some((v) => v < 0 || v > 1);
+    const scores = Float32Array.from(raw, (v) => (logits ? sigmoid(v) : v));
+    patches.push({ t: +((start * HOP) / RATE).toFixed(2), scores });
+  }
+  return patches;
+}
+
+/** Las `n` clases más probables de un parche. */
+export function top(scores, n = 3) {
+  return [...scores]
+    .map((p, i) => ({ name: CLASSES[i], p }))
+    .sort((a, b) => b.p - a.p)
+    .slice(0, n);
+}
+
+/**
+ * Familias de efectos de sonido, por las clases de AudioSet que las delatan. Comprobado con
+ * la biblioteca de efectos de Ignix (2026-10-06): los whoosh dan «Whoosh, swoosh, swish»
+ * 0,58–0,78; el pop «Plop» 0,95; el ding «Ding» 0,97; la cámara «Camera».
+ */
+export const SFX_FAMILIES = {
+  whoosh: ['Whoosh, swoosh, swish', 'Arrow'],
+  pop: ['Plop', 'Boing'],
+  ding: ['Ding', 'Chime', 'Bell', 'Jingle, tinkle', 'Ding-dong', 'Clang', 'Cash register'],
+  click: ['Tick', 'Clicking', 'Tap', 'Typing', 'Camera'],
+  impact: ['Thump, thud', 'Whack, thwack', 'Bang', 'Slap, smack', 'Boom', 'Explosion'],
+  notification: ['Telephone', 'Ringtone', 'Beep, bleep', 'Alarm'],
+  crowd: ['Applause', 'Clapping', 'Cheering', 'Laughter'],
+};
+const FAMILY_IDX = Object.fromEntries(Object.entries(SFX_FAMILIES).map(([k, names]) => [k, names.map((n) => CLASSES.indexOf(n)).filter((i) => i >= 0)]));
+const IDX = (name) => CLASSES.indexOf(name);
+const MUSIC = IDX('Music');
+const SPEECH = IDX('Speech');
+const GENERIC = IDX('Sound effect');
+export const SFX_MIN = 0.3;
+
+/**
+ * Lo que suena, resumido: cuánta música y cuánta voz (parte de los parches), y los efectos:
+ * cuántos por minuto, de qué familias y cuántos cortes llevan uno (±0,5 s).
+ */
+export function soundProfile(patches, { duration, cutTimes = [] } = {}) {
+  if (!patches.length) return null;
+  const events = [];
+  let music = 0;
+  let speech = 0;
+  for (const p of patches) {
+    if (p.scores[MUSIC] >= 0.3) music += 1;
+    if (p.scores[SPEECH] >= 0.3) speech += 1;
+    let best = null;
+    for (const [family, idx] of Object.entries(FAMILY_IDX)) {
+      const score = Math.max(...idx.map((i) => p.scores[i]));
+      if (score >= SFX_MIN && (!best || score > best.score)) best = { family, score };
+    }
+    if (!best && p.scores[GENERIC] >= SFX_MIN) best = { family: 'other', score: p.scores[GENERIC] };
+    if (!best) continue;
+    const t = p.t + PATCH_SEC / 2;
+    const last = events[events.length - 1];
+    // Parches que se solapan (cada 0,48 s) son el mismo sonido aunque lo vean como familias
+    // distintas (un ding también parece un teléfono): se queda la de más puntuación.
+    if (last && t - last.at < PATCH_SEC - 0.05) {
+      last.at = t;
+      if (best.score > last.score) Object.assign(last, { family: best.family, score: best.score });
+      continue;
+    }
+    events.push({ t: +t.toFixed(2), at: t, family: best.family, score: best.score });
+  }
+  const counts = {};
+  for (const e of events) counts[e.family] = (counts[e.family] ?? 0) + 1;
+  const minutes = Math.max(duration ?? patches.length * PATCH_HOP_SEC, 1) / 60;
+  const onCuts = cutTimes.filter((c) => events.some((e) => Math.abs(e.t - c) <= 0.5)).length;
+  return {
+    musicShare: +(music / patches.length).toFixed(2),
+    speechShare: +(speech / patches.length).toFixed(2),
+    sfxPerMinute: +(events.length / minutes).toFixed(2),
+    sfxOnCutsShare: cutTimes.length ? +(onCuts / cutTimes.length).toFixed(2) : null,
+    sfxTypes: Object.entries(counts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([family, count]) => ({ family, count })),
+    events: events.slice(0, 200).map((e) => ({ t: e.t, family: e.family })),
+  };
+}

package/src/analysis/audioset-classes.json

@@ -0,0 +1 @@
+["Speech", "Child speech, kid speaking", "Conversation", "Narration, monologue", "Babbling", "Speech synthesizer", "Shout", "Bellow", "Whoop", "Yell", "Children shouting", "Screaming", "Whispering", "Laughter", "Baby laughter", "Giggle", "Snicker", "Belly laugh", "Chuckle, chortle", "Crying, sobbing", "Baby cry, infant cry", "Whimper", "Wail, moan", "Sigh", "Singing", "Choir", "Yodeling", "Chant", "Mantra", "Child singing", "Synthetic singing", "Rapping", "Humming", "Groan", "Grunt", "Whistling", "Breathing", "Wheeze", "Snoring", "Gasp", "Pant", "Snort", "Cough", "Throat clearing", "Sneeze", "Sniff", "Run", "Shuffle", "Walk, footsteps", "Chewing, mastication", "Biting", "Gargling", "Stomach rumble", "Burping, eructation", "Hiccup", "Fart", "Hands", "Finger snapping", "Clapping", "Heart sounds, heartbeat", "Heart murmur", "Cheering", "Applause", "Chatter", "Crowd", "Hubbub, speech noise, speech babble", "Children playing", "Animal", "Domestic animals, pets", "Dog", "Bark", "Yip", "Howl", "Bow-wow", "Growling", "Whimper (dog)", "Cat", "Purr", "Meow", "Hiss", "Caterwaul", "Livestock, farm animals, working animals", "Horse", "Clip-clop", "Neigh, whinny", "Cattle, bovinae", "Moo", "Cowbell", "Pig", "Oink", "Goat", "Bleat", "Sheep", "Fowl", "Chicken, rooster", "Cluck", "Crowing, cock-a-doodle-doo", "Turkey", "Gobble", "Duck", "Quack", "Goose", "Honk", "Wild animals", "Roaring cats (lions, tigers)", "Roar", "Bird", "Bird vocalization, bird call, bird song", "Chirp, tweet", "Squawk", "Pigeon, dove", "Coo", "Crow", "Caw", "Owl", "Hoot", "Bird flight, flapping wings", "Canidae, dogs, wolves", "Rodents, rats, mice", "Mouse", "Patter", "Insect", "Cricket", "Mosquito", "Fly, housefly", "Buzz", "Bee, wasp, etc.", "Frog", "Croak", "Snake", "Rattle", "Whale vocalization", "Music", "Musical instrument", "Plucked string instrument", "Guitar", "Electric guitar", "Bass guitar", "Acoustic guitar", "Steel guitar, slide guitar", "Tapping (guitar technique)", "Strum", "Banjo", "Sitar", "Mandolin", "Zither", "Ukulele", "Keyboard (musical)", "Piano", "Electric piano", "Organ", "Electronic organ", "Hammond organ", "Synthesizer", "Sampler", "Harpsichord", "Percussion", "Drum kit", "Drum machine", "Drum", "Snare drum", "Rimshot", "Drum roll", "Bass drum", "Timpani", "Tabla", "Cymbal", "Hi-hat", "Wood block", "Tambourine", "Rattle (instrument)", "Maraca", "Gong", "Tubular bells", "Mallet percussion", "Marimba, xylophone", "Glockenspiel", "Vibraphone", "Steelpan", "Orchestra", "Brass instrument", "French horn", "Trumpet", "Trombone", "Bowed string instrument", "String section", "Violin, fiddle", "Pizzicato", "Cello", "Double bass", "Wind instrument, woodwind instrument", "Flute", "Saxophone", "Clarinet", "Harp", "Bell", "Church bell", "Jingle bell", "Bicycle bell", "Tuning fork", "Chime", "Wind chime", "Change ringing (campanology)", "Harmonica", "Accordion", "Bagpipes", "Didgeridoo", "Shofar", "Theremin", "Singing bowl", "Scratching (performance technique)", "Pop music", "Hip hop music", "Beatboxing", "Rock music", "Heavy metal", "Punk rock", "Grunge", "Progressive rock", "Rock and roll", "Psychedelic rock", "Rhythm and blues", "Soul music", "Reggae", "Country", "Swing music", "Bluegrass", "Funk", "Folk music", "Middle Eastern music", "Jazz", "Disco", "Classical music", "Opera", "Electronic music", "House music", "Techno", "Dubstep", "Drum and bass", "Electronica", "Electronic dance music", "Ambient music", "Trance music", "Music of Latin America", "Salsa music", "Flamenco", "Blues", "Music for children", "New-age music", "Vocal music", "A capella", "Music of Africa", "Afrobeat", "Christian music", "Gospel music", "Music of Asia", "Carnatic music", "Music of Bollywood", "Ska", "Traditional music", "Independent music", "Song", "Background music", "Theme music", "Jingle (music)", "Soundtrack music", "Lullaby", "Video game music", "Christmas music", "Dance music", "Wedding music", "Happy music", "Sad music", "Tender music", "Exciting music", "Angry music", "Scary music", "Wind", "Rustling leaves", "Wind noise (microphone)", "Thunderstorm", "Thunder", "Water", "Rain", "Raindrop", "Rain on surface", "Stream", "Waterfall", "Ocean", "Waves, surf", "Steam", "Gurgling", "Fire", "Crackle", "Vehicle", "Boat, Water vehicle", "Sailboat, sailing ship", "Rowboat, canoe, kayak", "Motorboat, speedboat", "Ship", "Motor vehicle (road)", "Car", "Vehicle horn, car horn, honking", "Toot", "Car alarm", "Power windows, electric windows", "Skidding", "Tire squeal", "Car passing by", "Race car, auto racing", "Truck", "Air brake", "Air horn, truck horn", "Reversing beeps", "Ice cream truck, ice cream van", "Bus", "Emergency vehicle", "Police car (siren)", "Ambulance (siren)", "Fire engine, fire truck (siren)", "Motorcycle", "Traffic noise, roadway noise", "Rail transport", "Train", "Train whistle", "Train horn", "Railroad car, train wagon", "Train wheels squealing", "Subway, metro, underground", "Aircraft", "Aircraft engine", "Jet engine", "Propeller, airscrew", "Helicopter", "Fixed-wing aircraft, airplane", "Bicycle", "Skateboard", "Engine", "Light engine (high frequency)", "Dental drill, dentist's drill", "Lawn mower", "Chainsaw", "Medium engine (mid frequency)", "Heavy engine (low frequency)", "Engine knocking", "Engine starting", "Idling", "Accelerating, revving, vroom", "Door", "Doorbell", "Ding-dong", "Sliding door", "Slam", "Knock", "Tap", "Squeak", "Cupboard open or close", "Drawer open or close", "Dishes, pots, and pans", "Cutlery, silverware", "Chopping (food)", "Frying (food)", "Microwave oven", "Blender", "Water tap, faucet", "Sink (filling or washing)", "Bathtub (filling or washing)", "Hair dryer", "Toilet flush", "Toothbrush", "Electric toothbrush", "Vacuum cleaner", "Zipper (clothing)", "Keys jangling", "Coin (dropping)", "Scissors", "Electric shaver, electric razor", "Shuffling cards", "Typing", "Typewriter", "Computer keyboard", "Writing", "Alarm", "Telephone", "Telephone bell ringing", "Ringtone", "Telephone dialing, DTMF", "Dial tone", "Busy signal", "Alarm clock", "Siren", "Civil defense siren", "Buzzer", "Smoke detector, smoke alarm", "Fire alarm", "Foghorn", "Whistle", "Steam whistle", "Mechanisms", "Ratchet, pawl", "Clock", "Tick", "Tick-tock", "Gears", "Pulleys", "Sewing machine", "Mechanical fan", "Air conditioning", "Cash register", "Printer", "Camera", "Single-lens reflex camera", "Tools", "Hammer", "Jackhammer", "Sawing", "Filing (rasp)", "Sanding", "Power tool", "Drill", "Explosion", "Gunshot, gunfire", "Machine gun", "Fusillade", "Artillery fire", "Cap gun", "Fireworks", "Firecracker", "Burst, pop", "Eruption", "Boom", "Wood", "Chop", "Splinter", "Crack", "Glass", "Chink, clink", "Shatter", "Liquid", "Splash, splatter", "Slosh", "Squish", "Drip", "Pour", "Trickle, dribble", "Gush", "Fill (with liquid)", "Spray", "Pump (liquid)", "Stir", "Boiling", "Sonar", "Arrow", "Whoosh, swoosh, swish", "Thump, thud", "Thunk", "Electronic tuner", "Effects unit", "Chorus effect", "Basketball bounce", "Bang", "Slap, smack", "Whack, thwack", "Smash, crash", "Breaking", "Bouncing", "Whip", "Flap", "Scratch", "Scrape", "Rub", "Roll", "Crushing", "Crumpling, crinkling", "Tearing", "Beep, bleep", "Ping", "Ding", "Clang", "Squeal", "Creak", "Rustle", "Whir", "Clatter", "Sizzle", "Clicking", "Clickety-clack", "Rumble", "Plop", "Jingle, tinkle", "Hum", "Zing", "Boing", "Crunch", "Silence", "Sine wave", "Harmonic", "Chirp tone", "Sound effect", "Pulse", "Inside, small room", "Inside, large room or hall", "Inside, public space", "Outside, urban or manmade", "Outside, rural or natural", "Reverberation", "Echo", "Noise", "Environmental noise", "Static", "Mains hum", "Distortion", "Sidetone", "Cacophony", "White noise", "Pink noise", "Throbbing", "Vibration", "Television", "Radio", "Field recording"]

package/src/analysis/runtime.mjs

@@ -70,8 +70,13 @@ export async function ensureModel(name, log = () => {}) {
     return p;
   }
   const dest = join(HOME, 'models', 'analysis', manifest.version, entry.file);
-  if (existsSync(dest)) return dest;
   const base = `${manifest.baseUrl}/${manifest.version}/models`;
+  // Ficheros que el modelo lee a su lado (pesos en un fichero aparte), con su sha256.
+  for (const x of entry.extra ?? []) {
+    const p = join(dirname(dest), x.file);
+    if (!existsSync(p)) await fetchChecked(`${base}/${x.file}`, p, { ...x, label: `${entry.label ?? entry.file} (weights)` }, log);
+  }
+  if (existsSync(dest)) return dest;
   if (!entry.parts) {
     await fetchChecked(`${base}/${entry.file}`, dest, entry, log);
     return dest;
@@ -122,7 +127,9 @@ export function analysisMissing() {
   if (!process.env.IGNIX_EDITOR_ORT && rt && !existsSync(join(rtDir, 'onnxruntime-node', 'package.json'))) out.push({ item: 'runtime', size: rt.size });
   for (const [name, entry] of Object.entries(manifest.models)) {
     if (process.env.IGNIX_EDITOR_MODELS) continue;
-    if (!existsSync(join(HOME, 'models', 'analysis', manifest.version, entry.file))) out.push({ item: name, size: entry.size });
+    const dir = join(HOME, 'models', 'analysis', manifest.version);
+    const missing = [entry, ...(entry.extra ?? [])].filter((f) => !existsSync(join(dir, f.file)));
+    if (missing.length) out.push({ item: name, size: missing.reduce((n, f) => n + f.size, 0) });
   }
   return out;
 }

package/src/analysis/serve.mjs

@@ -16,6 +16,7 @@ import { frames, probe } from './media.mjs';
 import { analyze, edit, review } from './montage.mjs';
 import { RUNTIME_VERSION, loadOrt } from './runtime.mjs';
 import { cleanVoice, structure } from './sound.mjs';
+import { measureStyle } from './style.mjs';
 
 const MAX_SAMPLES = 2400;
 const log = (...a) => console.error(...a);
@@ -99,6 +100,15 @@ export function createOps({ version, engine }) {
       return structure({ ffmpeg, path: req.path });
     },
 
+    // El estilo de edición medido en 1–5 vídeos (ADR-0023 E3); con `speech`, también el habla.
+    async style(req) {
+      const { ffmpeg, ffprobe } = await tools();
+      const speech = req.speech
+        ? { whisper: await ensureTool('whisper', log), model: await ensureWhisperModel('small', log), language: req.language ?? null }
+        : null;
+      return measureStyle({ ffmpeg, ffprobe, paths: req.paths, speech, stills: req.stills ?? null, log });
+    },
+
     async analyze(req) {
       const { ffmpeg, ffprobe } = await tools();
       return analyze({ ffmpeg, ffprobe, workdir: req.workdir, media: req.media ?? [], log });