@ignix-social/editor 0.1.0

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 HeyGen, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,54 @@
+Ignix Editor
+Copyright 2026 Ignix
+
+This product includes software developed by HeyGen, Inc. as part of
+HyperFrames (https://github.com/heygen-com/hyperframes), licensed under the
+Apache License, Version 2.0. A copy of that license is in the LICENSE file.
+
+The HyperFrames code is in vendor/hyperframes. It is distributed with
+modifications made by Ignix; every modification is listed, with the exact
+original text it replaces, in patches/index.mjs, and the list of patches
+applied to the shipped copy is recorded in vendor/hyperframes/UPSTREAM.json.
+
+"HyperFrames" and "HeyGen" are names of HeyGen, Inc. Ignix Editor is not
+affiliated with or endorsed by HeyGen, Inc.
+
+-------------------------------------------------------------------------------
+Binaries downloaded by Ignix Editor (into ~/.ignix-editor, never bundled in
+this package)
+
+FFmpeg 7.1.2 (ffmpeg, ffprobe) — https://ffmpeg.org
+  Licensed under the GNU Lesser General Public License, version 2.1 or later.
+  Built without any GPL or non-free component (--disable-gpl --disable-nonfree)
+  using scripts/build-ffmpeg-macos.sh in this repository, which records the
+  exact configuration. The corresponding source code is available at
+  https://media.ignix.social/editor/bin/1/source/ffmpeg-7.1.2.tar.xz
+  and from https://ffmpeg.org/releases/ffmpeg-7.1.2.tar.xz.
+
+whisper.cpp v1.7.6 (whisper-cli) — https://github.com/ggml-org/whisper.cpp
+  Built with scripts/build-whisper-macos.sh. Its license:
+
+  MIT License
+  
+  Copyright (c) 2023-2024 The ggml authors
+  
+  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.
+
+Whisper models (ggml-*.bin) are downloaded from
+https://huggingface.co/ggerganov/whisper.cpp under the MIT license.

package/README.md

@@ -0,0 +1,23 @@
+# Ignix Editor
+
+Render videos from HTML on your own computer: reels made from scratch, edits of your recorded videos and clips from long ones. It is the video engine behind Ignix's reel and edit playbooks for AI assistants (Claude, ChatGPT) and behind Ignix Creator.
+
+```sh
+npx @ignix-social/editor doctor        # checks Node 22+, ffmpeg, whisper and the H.264 encoder
+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`.
+
+- Everything runs locally; your footage never leaves your machine.
+- ffmpeg (LGPL build) 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.
+- `ignix-editor skills add` installs the `ignix-editor` skill for Claude.
+
+Requires Node.js 22 or newer. macOS first; Windows next.
+
+## License
+
+Apache-2.0. Ignix Editor is based on [HyperFrames](https://github.com/heygen-com/hyperframes) by HeyGen, Inc. (Apache-2.0), included in `vendor/hyperframes` with the modifications listed in `patches/`. See `NOTICE`. Ignix Editor is not affiliated with or endorsed by HeyGen.

package/bin/ignix-editor.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+const major = Number(process.versions.node.split('.')[0]);
+if (major < 22) {
+  console.error(`Ignix Editor necesita Node 22 o superior (tienes ${process.versions.node}). Instala la versión LTS desde nodejs.org.`);
+  process.exit(1);
+}
+const { main } = await import('../src/cli.mjs');
+await main(process.argv.slice(2));

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@ignix-social/editor",
+  "version": "0.1.0",
+  "description": "Ignix Editor: render HTML video compositions (reels, edits, clips) on your own computer. Based on HyperFrames.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "ignix-editor": "./bin/ignix-editor.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skills",
+    "templates",
+    "vendor",
+    "patches",
+    "scripts",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "vendor": "node scripts/vendor.mjs",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@fontsource/montserrat": "^5.3.0",
+    "@hono/node-server": "^2.0.5",
+    "@puppeteer/browsers": "^3.2.2",
+    "adm-zip": "^0.6.0",
+    "citty": "^0.2.1",
+    "compare-versions": "^6.1.1",
+    "css-tree": "^3.2.1",
+    "debug": "^4.4.0",
+    "esbuild": "^0.25.12",
+    "fontkit": "^2.0.4",
+    "giget": "^3.2.0",
+    "gsap": "^3.14.2",
+    "hono": "^4.0.0",
+    "ignore": "^5.3.2",
+    "open": "^10.0.0",
+    "parse5": "^7.3.0",
+    "postcss": "^8.5.8",
+    "prettier": "^3.8.1",
+    "puppeteer-core": "^25.10.0",
+    "sharp": "^0.35.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/patches/index.mjs

@@ -0,0 +1,53 @@
+// 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 { readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+function replaceAnchor(dist, { anchor, replacement, expect = 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 !== expect) throw new Error(`Ancla encontrada ${hits} veces (se esperaban ${expect}): ${anchor.slice(0, 80)}…`);
+}
+
+export const patches = [
+  {
+    id: 'no-telemetry',
+    // Ningún evento sale hacia PostHog: la cola nunca se llena, así que no hay nada que enviar.
+    apply: (dist) => {
+      replaceAnchor(dist, {
+        anchor: 'function enqueue(event, properties, distinctId) {\n  eventQueue.push({',
+        replacement: 'function enqueue(event, properties, distinctId) {\n  return; // ignix-editor: telemetría eliminada\n  eventQueue.push({',
+      });
+      replaceAnchor(dist, {
+        anchor: 'if (!isHelp && command !== "telemetry" && command !== "events" && command !== "usage" && command !== "unknown") {',
+        replacement: 'if (false) { // ignix-editor: sin aviso ni registro de telemetría',
+      });
+    },
+  },
+  {
+    id: 'no-auto-update',
+    // Versión fijada: nada de comprobar ni instalar versiones nuevas por su cuenta.
+    apply: (dist) =>
+      replaceAnchor(dist, {
+        anchor: 'if (!isHelp && !hasJsonFlag && command !== "upgrade" && command !== "events" && command !== "telemetry" && command !== "skills" && command !== "usage") {',
+        replacement: 'if (false) { // ignix-editor: sin comprobación ni instalación automática de versiones',
+      }),
+  },
+  {
+    id: 'no-desktop-promo',
+    // Sin publicidad de la app de escritorio de HeyGen al terminar un render.
+    apply: (dist) =>
+      replaceAnchor(dist, {
+        anchor: '  if (env.HYPERFRAMES_DESKTOP_PROJECT) return null;\n  if (ready && (installed ?? desktopInstalled({ platform, env })))',
+        replacement: '  return null; // ignix-editor: sin aviso de la app de escritorio\n  if (ready && (installed ?? desktopInstalled({ platform, env })))',
+      }),
+  },
+];

package/scripts/build-ffmpeg-macos.sh

@@ -0,0 +1,35 @@
+#!/bin/sh
+# Compila ffmpeg + ffprobe LGPL para macOS (sin libx264 ni nada GPL/non-free).
+# HyperFrames codifica entonces con VideoToolbox (h264_videotoolbox), el codificador del Mac.
+# Uso: scripts/build-ffmpeg-macos.sh [dir-de-trabajo]  → <dir>/out/{ffmpeg,ffprobe}
+set -eu
+NASM_VERSION=2.16.03
+FFMPEG_VERSION=7.1.2
+WORK=${1:-"$HOME/ignix-editor-build/ffmpeg-macos-$(uname -m)"}
+JOBS=$(sysctl -n hw.ncpu)
+mkdir -p "$WORK" && cd "$WORK"
+
+# nasm (solo para compilar: acelera la decodificación x86; en arm64 no hace falta)
+if [ "$(uname -m)" = "x86_64" ] && [ ! -x tools/bin/nasm ]; then
+  curl -sfL "https://www.nasm.us/pub/nasm/releasebuilds/$NASM_VERSION/nasm-$NASM_VERSION.tar.xz" -o nasm.tar.xz
+  tar xf nasm.tar.xz && cd "nasm-$NASM_VERSION"
+  ./configure --prefix="$WORK/tools" >/dev/null && make -j"$JOBS" >/dev/null && make install >/dev/null
+  cd "$WORK"
+fi
+export PATH="$WORK/tools/bin:$PATH"
+
+[ -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" \
+  --disable-gpl --disable-nonfree --disable-version3 \
+  --disable-debug --disable-doc --disable-ffplay \
+  --disable-shared --enable-static \
+  --enable-videotoolbox --enable-audiotoolbox \
+  --enable-zlib --enable-bzlib --enable-iconv \
+  --disable-sdl2 --disable-xlib --disable-libxcb \
+  --extra-cflags="-mmacosx-version-min=11.0" --extra-ldflags="-mmacosx-version-min=11.0" >/dev/null
+make -j"$JOBS" >/dev/null
+mkdir -p "$WORK/out" && cp ffmpeg ffprobe "$WORK/out/"
+"$WORK/out/ffmpeg" -hide_banner -version | head -3
+echo "LISTO: $WORK/out"

package/scripts/build-whisper-macos.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# Compila whisper-cli (whisper.cpp, MIT) como binario autónomo para macOS: el cliente no
+# necesita Homebrew, cmake ni Xcode. cmake se instala en un entorno aislado de Python.
+# Uso: scripts/build-whisper-macos.sh [dir-de-trabajo]  → <dir>/out/whisper-cli
+set -eu
+WHISPER_VERSION=v1.7.6
+WORK=${1:-"$HOME/ignix-editor-build/whisper-macos-$(uname -m)"}
+JOBS=$(sysctl -n hw.ncpu)
+mkdir -p "$WORK" && cd "$WORK"
+
+[ -x venv/bin/cmake ] || { python3 -m venv venv && venv/bin/pip install --quiet cmake; }
+export PATH="$WORK/venv/bin:$PATH"
+
+[ -d whisper.cpp ] || git clone --quiet --depth 1 --branch "$WHISPER_VERSION" https://github.com/ggml-org/whisper.cpp.git
+cd whisper.cpp
+cmake -B build -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DWHISPER_BUILD_TESTS=OFF -DWHISPER_BUILD_SERVER=OFF \
+  -DGGML_NATIVE=OFF -DCMAKE_OSX_DEPLOYMENT_TARGET=11.0 >/dev/null
+cmake --build build --config Release -j"$JOBS" --target whisper-cli >/dev/null
+mkdir -p "$WORK/out" && cp build/bin/whisper-cli "$WORK/out/"
+otool -L "$WORK/out/whisper-cli" | sed 1d
+echo "LISTO: $WORK/out"

package/scripts/vendor.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// Trae la versión FIJADA de HyperFrames (npm `hyperframes`, Apache-2.0) a vendor/hyperframes
+// y le aplica los parches de patches/. Actualizar = cambiar UPSTREAM_VERSION y volver a
+// ejecutarlo: si un parche ya no encuentra su ancla, falla en voz alta en vez de seguir.
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { cpSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { patches } from '../patches/index.mjs';
+
+export const UPSTREAM_VERSION = '0.8.132';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '..');
+const dest = join(root, 'vendor', 'hyperframes');
+const tmp = mkdtempSync(join(tmpdir(), 'ignix-editor-vendor-'));
+
+try {
+  execFileSync('npm', ['pack', `hyperframes@${UPSTREAM_VERSION}`, '--silent'], { cwd: tmp, stdio: ['ignore', 'pipe', 'inherit'] });
+  const tgz = readdirSync(tmp).find((f) => f.endsWith('.tgz'));
+  const sha512 = createHash('sha512').update(readFileSync(join(tmp, tgz))).digest('base64');
+  execFileSync('tar', ['xzf', tgz], { cwd: tmp });
+
+  rmSync(dest, { recursive: true, force: true });
+  cpSync(join(tmp, 'package'), dest, { recursive: true });
+
+  const applied = [];
+  for (const p of patches) {
+    p.apply(join(dest, 'dist'));
+    applied.push(p.id);
+  }
+
+  writeFileSync(
+    join(dest, 'UPSTREAM.json'),
+    JSON.stringify({ package: 'hyperframes', version: UPSTREAM_VERSION, integrity: `sha512-${sha512}`, license: 'Apache-2.0', source: 'https://github.com/heygen-com/hyperframes', patches: applied }, null, 2) + '\n',
+  );
+  console.log(`hyperframes@${UPSTREAM_VERSION} en vendor/hyperframes · parches: ${applied.join(', ')}`);
+} finally {
+  rmSync(tmp, { recursive: true, force: true });
+}

package/skills/ignix-editor/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: ignix-editor
+description: Build and render videos with Ignix Editor (HTML + GSAP compositions rendered to MP4 on the user's machine) — reels made from scratch, edits of the user's own recorded videos, clips cut from long videos. Use whenever an Ignix playbook (get_reel_playbook, get_edit_playbook) says to build with Ignix Editor, or the user asks to make, edit or render a video with it. Covers project setup, the composition contract, frame-pure animation with IgnixFrame, recorded-video cuts and reframing, audio, captions from transcription, the traps that silently break renders, and the check → snapshot → render review loop.
+---
+
+# Ignix Editor
+
+Ignix Editor turns an HTML page into an MP4. You write `index.html` (layout in HTML/CSS, motion in JS), the editor renders it frame by frame in a headless browser and encodes it with ffmpeg. The Ignix playbooks say WHAT to make; this skill says HOW to write it so that what you write is what renders.
+
+Commands (`npx @ignix-social/editor <cmd>` if `ignix-editor` is not on the PATH):
+
+| Command | What it does |
+|---|---|
+| `ignix-editor doctor` | Node 22+, ffmpeg, whisper, H.264 encoder. Run it first. |
+| `ignix-editor init <name>` | Creates `~/ignix-videos/<name>` with a working skeleton, GSAP, local fonts and `ignix-frame.js`. |
+| `ignix-editor transcribe <file> --lang es [--script "…"] -o words.json` | Words with start/end seconds, on this machine. |
+| `ignix-editor check [dir]` | HTML well-formed, no network assets, media rules, layout/contrast/motion audit. |
+| `ignix-editor snapshot [dir] --at 0,1.5,3` | PNG frames into `<dir>/snapshots/` to LOOK at. |
+| `ignix-editor render [dir] [-o out.mp4]` | Renders to `<dir>/renders/<dir>.mp4`, audio normalised to −14 LUFS. |
+| `ignix-editor ffmpeg …` / `ffprobe …` | The editor's own ffmpeg (do not rely on a system one). |
+
+One project = one folder with `index.html` at its root and everything it uses inside `assets/`. Never work inside the user's code repository.
+
+## 1. The composition contract
+
+```html
+<div id="root" data-composition-id="myreel" data-width="1080" data-height="1920" data-duration="18.9" data-fps="30"> … </div>
+```
+
+- `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`.
+
+### Media: written in the HTML, never created by JS
+
+The engine reads `<video>`/`<audio>` from the HTML file before the page runs. Media created with `createElement` or `innerHTML` renders black or silent (`check` reports `media_from_js`). When media comes from data (cuts, voice lines, sound effects), write the HTML with a small Node build script first (pattern in section 5).
+
+```html
+<video id="cut1" src="assets/take.mp4" muted playsinline data-start="0" data-duration="2.9667" data-media-start="0.1" data-track-index="0"></video>
+<audio id="vo1" src="assets/vo/l1.wav" data-start="0" data-duration="3.64" data-track-index="10" data-volume="1"></audio>
+<audio id="sfx3" src="assets/sfx/click.mp3" data-start="4.88" data-duration="0.4" data-track-index="23" data-volume="0.45"></audio>
+```
+
+- `data-start` = when it appears in the video; `data-duration` = how long; `data-media-start` = where in the source file it starts (trim in). One `<video>` per kept piece of a recording; the same source file can be used many times.
+- Every `<video>`/`<audio>` has a unique `id`. An `<audio>` without id is silently dropped from the mix.
+- Footage you show without its sound: `muted`. A video whose own sound you keep: `data-has-audio="true"` and no `muted`.
+- Give each sound effect its own `data-track-index` (overlapping sounds on one track get a warning).
+- Never put `data-start` on BOTH a video and an element that contains it: time the video, and put a plain (untimed) wrapper around it for zoom/crop/position.
+- Never add `crossorigin` to media. Never call `play()`, `pause()` or set `currentTime`: the engine owns playback.
+- Fades and ducking: a volume lane on the element, e.g. 8 ms fades at each cut so it does not click:
+  `data-automation='{"version":1,"lanes":[{"target":"volume","points":[{"t":0,"v":0},{"t":0.008,"v":1},{"t":2.95,"v":1},{"t":2.9667,"v":0}]}]}'` (`t` is seconds from the clip's own start).
+- Times are snapped to the nearest frame by the editor; still write them with enough decimals (frame / fps).
+
+### Everything local
+
+No `http(s)://` in scripts, styles, fonts, images or media: download into `assets/` (`curl -o`). Fonts: `@font-face` with a file in `assets/fonts/` and `font-display: block`. Web fonts arrive late in some frames and those frames render in a fallback serif.
+
+## 2. Motion: a pure function of time
+
+```js
+const { run, lerp, spring, keyed, ease } = IgnixFrame;
+run({ id: 'myreel', duration: 18.9, fps: 30 }, (t) => {
+  // everything visible at second t is computed from t alone
+  title.style.opacity = lerp(t, [0, 0.3], [0, 1], ease.out);
+  card.style.transform = `scale(${0.6 + 0.4 * spring(t - 1.2, { stiffness: 220, damping: 14 })})`;
+});
+```
+
+The renderer asks for frames independently (in parallel, out of order). If frame N depends only on N, it renders exactly like the preview. So:
+
+- No state carried between frames (no counters incremented per call, no "if it already appeared"). Derive everything from `t`.
+- `lerp(t, [t0, t1], [v0, v1], ease)` clamps outside the range. `spring(t − start)` is 0 before its start and settles to 1. `keyed(t, [[t, value], …], dur)` moves to each new value over `dur` (numbers or arrays: positions, rectangles, camera rects). Eases: `ease.out` (default entrance), `ease.inOut` (camera), `ease.in`, `ease.outCubic`, `ease.inOutSine`.
+- Use `transform` (translate/scale/rotate) and `opacity` for motion; animating `left/top/width/height/font-size` snaps to whole pixels and stutters in slow moves.
+- Toggling `display`, `textContent` or a class from `t` is fine (typed text: `KEY.slice(0, n(t))`).
+
+### Never measure the page while rendering
+
+Do not call `getBoundingClientRect()`/`offsetLeft` to aim arrows, cursors or highlight boxes: fonts may not be ready and layout may differ per frame; arrows pointed 300 px off and vanished in a test because of this. Instead, give the recreated UI fixed coordinates and keep a table:
+
+```js
+// app window is 1000×640 in its own coordinates; children are absolutely positioned from these numbers
+const T = { menuItem: [16, 306, 188, 40], keyField: [260, 156, 700, 58], toggle: [888, 421, 72, 38] };
+const centre = ([x, y, w, h]) => [x + w / 2, y + h / 2];
+```
+
+Position the elements with the SAME numbers in CSS. Cursor paths, click ripples and highlight rectangles read from `T`. Scale the whole window with one `transform` for the camera.
+
+### A camera inside a fixed stage
+
+Decide the zones once per video (e.g. header y 270–440, stage y 460–1300, captions y 1335–1465 on a 1080×1920 reel) and keep them. Put zoomable content (an app window, a phone) inside a stage element with `overflow:hidden`, and move a camera by transforming the content inside it: zooming in then never covers the header or the captions. A soft mask on the stage edges hides the crop.
+
+## 3. Recorded video (edits and clips)
+
+- Transcribe on the machine: `ignix-editor transcribe assets/take.mp4 --lang es -o work/words.json`. Show the user the text and fix obvious mishearings (names, brands) without rewriting what they said.
+- Cuts: one `<video>` per kept range, edge to edge (`data-start` of the next = previous start + duration). Build a map from source time to edited time and pass every word time, zoom, overlay and sound through it.
+- Voice clean-up before building: `ignix-editor ffmpeg -i take.mp4 -vn -ac 1 -ar 48000 -af "highpass=f=80,acompressor=threshold=-22dB:ratio=3:attack=5:release=120:makeup=2" assets/voice.wav`, then one `<audio>` per kept range with `data-media-start` and 8 ms fade lanes, and the videos `muted`.
+- Reframing a horizontal source to 9:16 and following the face: a fixed card/frame element with `overflow:hidden`; inside it a wrapper sized like the card, `transform-origin:0 0`, moved with `translate(-x·z, -y·z) scale(z)` per frame from a face path (one point per frame, smoothed). Zooms multiply `z`.
+- Blurred background of the same footage: a second set of the same `<video>` elements behind, in a wrapper with `filter: blur(60px) brightness(.32)` and `transform: scale(1.25)`. (Heavy without a GPU: on a machine without one, prefer a pre-blurred copy made with ffmpeg.)
+- Long sources (lives, podcasts) are fine: the editor seeks straight to `data-media-start`.
+
+## 4. Audio and captions for reels from scratch
+
+- One `<audio>` per voice line (Ignix `generate_voiceover`), placed back to back with ~0.25 s of air: the scenes follow the voice.
+- Word times: `ignix-editor transcribe assets/vo/l1.wav --lang es --script "<the exact line>" -o work/l1.json`. With `--script` the words are the script's and the times are whisper's (whisper mishears and sometimes drops the last words; the script wins).
+- Anchor every gesture (click, pop, highlight, cut) to a word time: `cue = line.start + word.s`. Sound effects start on their gesture.
+- Captions: groups of 2–3 words that never cross the end of a line; current word in the brand accent; font size shrinks for long groups so they fit the ~820 px column.
+- The final mix is normalised to −14 LUFS by `render` (`--lufs` to change, `--no-normalize` to skip).
+
+## 5. Generate the HTML from data
+
+When there are many clips, lines or cues, keep them in data and let a script write the media tags and the timing file:
+
+```
+work/      transcripts, edit decisions (JSON)
+build.mjs  reads work/ + durations (ignix-editor ffprobe) → writes assets/timing.js and the <video>/<audio> tags between markers in index.html
+```
+
+Re-run it whenever the voice or the cuts change; the animation code reads `window.R` from `assets/timing.js` and never hardcodes seconds.
+
+## 6. Traps that do not error
+
+- `id="caption"` is special to the engine and changes the font: use `subs`.
+- Centring with CSS `transform: translate(-50%,-50%)` on an element you also transform from JS fights; centre with flex/inset instead.
+- Emojis render with the operating system's emoji font (different design on other machines).
+- An element that ends past `data-duration` is cut; a timeline shorter than it holds the last frame.
+- `check` reports layout overlaps: real ones (a zoomed window under the header) must be fixed; intentional ones get `data-layout-allow-overlap` / `data-layout-allow-overflow` on the element.
+
+## 7. Review before showing anything
+
+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.