@litfamily/lithermes 1.0.7 → 1.0.9

package/assets/lithermes-plugin/skills/lit-typographic-motion/bin/runtime.mjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+// LitHermes motion runtime: install-time pre-warm and read-only status.
+// Cache mechanics follow this product's office runtime (lockfile-digest cache
+// under ${XDG_CACHE_HOME:-$HERMES_HOME/.cache}, an exclusive install lock,
+// `npm ci --omit=dev --ignore-scripts` into a staging dir, atomic rename), but
+// nothing here ever runs on first render: `lithermes motion-runtime install`
+// and the product installer are the only callers of install() (MO-A-42/43).
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const skillRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+export const runtimeRoot = join(skillRoot, 'runtime');
+const pins = JSON.parse(readFileSync(join(runtimeRoot, 'fonts.json'), 'utf8'));
+const wordTiming = JSON.parse(readFileSync(join(runtimeRoot, 'word-timing.json'), 'utf8'));
+const lockBytes = readFileSync(join(runtimeRoot, 'package-lock.json'));
+const audioLockBytes = readFileSync(join(runtimeRoot, 'requirements.lock'));
+const sha = (data) => createHash('sha256').update(data).digest('hex');
+export const digest = createHash('sha256').update(lockBytes).update(readFileSync(join(runtimeRoot, 'fonts.json'))).digest('hex').slice(0, 16);
+export const audioDigest = sha(audioLockBytes).slice(0, 16);
+export const WARM = 'lithermes motion-runtime install';
+export const FONT_PINS = pins.entries;
+
+// This product's own lit-pptx Hangul pair, checked against its recorded hashes (MO-A-55).
+export const HANGUL_PAIR = Object.freeze([
+  { id: 'pretendard-400', file: 'PretendardGOV-Regular.otf', sha256: 'e8c1d911bda79376b2029be4f1c61c1d5b48a9459123a80d5ea23dd055f70bb6' },
+  { id: 'pretendard-700', file: 'PretendardGOV-Bold.otf', sha256: 'a3cd22c442e4ddb8e29501ca2136bfd9d187c70d608cd9feeaead09e4da7be19' },
+]);
+export const hangulPath = (file) => join(skillRoot, '..', 'lit-pptx', 'pretendard-font', 'public', 'static', file);
+
+// Cache roots, first match wins for reads; the first entry receives installs.
+export function cacheRoots(env = process.env) {
+  const roots = [];
+  if (env.XDG_CACHE_HOME) roots.push(env.XDG_CACHE_HOME);
+  if (env.HERMES_HOME) roots.push(join(env.HERMES_HOME, '.cache'));
+  const marker = `${sep}plugins${sep}lithermes${sep}skills${sep}`;
+  if (skillRoot.includes(marker)) roots.push(join(skillRoot.slice(0, skillRoot.indexOf(marker)), '.cache'));
+  roots.push(join(env.HOME || homedir(), '.cache'));
+  return [...new Set(roots)].map((root) => join(root, 'lithermes', 'motion', digest));
+}
+
+const readyAt = (cache) => existsSync(join(cache, 'READY')) && readFileSync(join(cache, 'READY'), 'utf8') === `${digest}\n`
+  && existsSync(join(cache, 'node', 'node_modules', 'playwright-core', 'package.json'));
+
+export function findCache(env = process.env) {
+  return cacheRoots(env).find(readyAt) || null;
+}
+
+export function depState(env = process.env) {
+  const cache = findCache(env);
+  return cache ? { ready: true, cache } : { ready: false, cache: cacheRoots(env)[0], missing: ['node dependencies (playwright-core, ws, opentype.js, pngjs)'] };
+}
+
+export function runtimeRequire(env = process.env) {
+  const cache = findCache(env);
+  if (!cache) throw Object.assign(new Error(`BLOCKED_DEPS_NOT_PREWARMED: pinned engine dependencies are not in the product cache; run \`${WARM}\` outside this session`), { exitCode: 14 });
+  const require = createRequire(join(cache, 'node', 'package.json'));
+  return (name) => require(name);
+}
+
+export function fontFile(cache, entryPath) {
+  return join(cache, 'assets', entryPath);
+}
+
+// MO-A-55: every pinned font and licence present with its recorded sha256, plus
+// the reused lit-pptx pair against this product's own hashes.
+export function fontState(env = process.env) {
+  const cache = findCache(env) || cacheRoots(env)[0];
+  const missing = [], mismatched = [];
+  for (const entry of pins.entries) {
+    const file = fontFile(cache, entry.path);
+    if (!existsSync(file)) missing.push(entry.path);
+    else if (sha(readFileSync(file)) !== entry.sha256) mismatched.push(entry.path);
+  }
+  for (const pair of HANGUL_PAIR) {
+    const file = hangulPath(pair.file);
+    if (!existsSync(file)) missing.push(`lit-pptx/${pair.file}`);
+    else if (sha(readFileSync(file)) !== pair.sha256) mismatched.push(`lit-pptx/${pair.file}`);
+  }
+  for (const name of ['EMS-OFL.txt', 'CREDITS']) if (!existsSync(join(runtimeRoot, 'licenses', name))) missing.push(`licenses/${name}`);
+  return { cache, missing, mismatched, ok: !missing.length && !mismatched.length };
+}
+
+function run(cmd, args, options = {}) {
+  const result = spawnSync(cmd, args, { encoding: 'utf8', ...options });
+  if (result.error || result.status !== 0) {
+    const detail = result.error?.message || (result.stderr || '').trim().split('\n').slice(-3).join(' ') || `exit ${result.status}`;
+    throw new Error(`${cmd} ${args[0] || ''} failed: ${detail}`);
+  }
+  return result.stdout;
+}
+
+// Pinned URL + sha256, verified before it lands; a mirror (file:// or http://127.0.0.1)
+// replaces the host part for offline tests.
+export async function fetchPinned(entry, targetFile, { mirror = process.env.LITHERMES_MOTION_FONT_MIRROR } = {}) {
+  const url = mirror ? `${mirror.replace(/\/$/, '')}/${entry.path}` : entry.url;
+  let bytes;
+  if (url.startsWith('file://')) bytes = readFileSync(fileURLToPath(url));
+  else {
+    const response = await fetch(url, { redirect: 'follow' });
+    if (!response.ok) throw new Error(`${entry.path}: HTTP ${response.status} from ${url}`);
+    bytes = Buffer.from(await response.arrayBuffer());
+  }
+  const got = sha(bytes);
+  if (got !== entry.sha256) throw new Error(`${entry.path}: sha256 mismatch (got ${got}, pinned ${entry.sha256})`);
+  mkdirSync(dirname(targetFile), { recursive: true });
+  writeFileSync(targetFile, bytes, { flag: 'wx' });
+}
+
+function pythonFor(env) {
+  const candidates = [env.LITHERMES_MOTION_PYTHON, 'python3.11', 'python3.12', 'python3.13', 'python3'].filter(Boolean);
+  for (const candidate of candidates) {
+    const probe = spawnSync(candidate, ['-c', 'import sys; print(sys.version.split()[0])'], { encoding: 'utf8' });
+    if (probe.status === 0) return { python: candidate, version: probe.stdout.trim() };
+  }
+  return null;
+}
+
+export const audioDir = (cache) => join(cache, `audio-${audioDigest}`);
+
+// Tier 2 state: absent, pins drifted, or ready. Never repaired in session (MO-A-54).
+export function audioState(env = process.env) {
+  const cache = findCache(env) || cacheRoots(env)[0];
+  const dir = audioDir(cache);
+  const python = join(dir, 'venv', 'bin', 'python');
+  if (!existsSync(python) || !existsSync(join(dir, 'AUDIO_READY'))) return { state: 'absent', python: null, dir };
+  const expected = [...audioLockBytes.toString().matchAll(/^([A-Za-z0-9_.-]+)==([A-Za-z0-9_.+-]+)/gm)].map(([, name, version]) => [name, version]);
+  const script = [
+    'import importlib.metadata as m, json, sys',
+    'bad = []',
+    'for name, version in json.loads(sys.argv[1]):',
+    '    try:',
+    '        if m.version(name) != version: bad.append(name)',
+    '    except Exception: bad.append(name)',
+    'print(json.dumps(bad))',
+  ].join('\n');
+  const check = spawnSync(python, ['-c', script, JSON.stringify(expected)], { encoding: 'utf8', timeout: 20000 });
+  if (check.status !== 0) return { state: 'mismatched', python, dir, detail: (check.stderr || '').trim().split('\n').at(-1) };
+  const bad = JSON.parse(check.stdout || '[]');
+  return bad.length ? { state: 'mismatched', python, dir, detail: `pins drifted: ${bad.join(', ')}` } : { state: 'ready', python, dir };
+}
+
+async function installAudio(cache, env) {
+  const py = pythonFor(env);
+  if (!py) throw new Error('no python3 interpreter found for the --audio venv (set LITHERMES_MOTION_PYTHON)');
+  const dir = audioDir(cache);
+  const stage = `${dir}.stage-${process.pid}`;
+  rmSync(stage, { recursive: true, force: true });
+  run(py.python, ['-m', 'venv', join(stage, 'venv')]);
+  run(join(stage, 'venv', 'bin', 'python'), ['-m', 'pip', 'install', '--disable-pip-version-check', '--require-hashes', '--only-binary=:all:', '-r', join(runtimeRoot, 'requirements.lock')], { timeout: 900000 });
+  writeFileSync(join(stage, 'AUDIO_READY'), `${audioDigest}\n`);
+  rmSync(dir, { recursive: true, force: true });
+  renameSync(stage, dir);
+  return `audio venv READY (${py.python} ${py.version})`;
+}
+
+export function wordTimingPlan() {
+  const lines = ['word-timing models (Tier 3, opt-in):'];
+  for (const m of wordTiming.models) lines.push(`  ${m.role}: ${m.id || 'NOT PINNED'} revision=${m.revision || 'none'} licence=${m.license || 'unknown'}${m.note ? ` (${m.note})` : ''}`);
+  lines.push(`  download size: ${wordTiming.status === 'pinned' ? wordTiming.downloadBytes + ' bytes' : '0 bytes (nothing is downloaded: fail-closed)'}`);
+  return { lines, pinned: wordTiming.status === 'pinned', reason: wordTiming.reason };
+}
+
+export function wordTimingReady(env = process.env) {
+  if (wordTiming.status !== 'pinned') return false;
+  const cache = findCache(env);
+  return Boolean(cache && existsSync(join(cache, 'word-timing', 'READY')));
+}
+
+export async function install({ audio = false, wordTiming: wantWords = false, env = process.env } = {}) {
+  if (wantWords) {
+    const plan = wordTimingPlan();
+    const error = new Error(`${plan.lines.join('\n')}\nword-timing install refused (fail-closed): ${plan.reason}`);
+    error.exitCode = 14;
+    throw error;
+  }
+  const roots = cacheRoots(env);
+  const existing = findCache(env);
+  const cache = existing || roots[0];
+  const receipts = [];
+  if (!existing || !fontState(env).ok) {
+    mkdirSync(dirname(cache), { recursive: true });
+    const lockPath = `${cache}.lock`;
+    let fd;
+    try { fd = openSync(lockPath, 'wx'); } catch (error) {
+      if (error.code === 'EEXIST') throw new Error(`another motion-runtime install holds ${lockPath}`);
+      throw error;
+    }
+    const stage = `${cache}.stage-${process.pid}`;
+    try {
+      rmSync(stage, { recursive: true, force: true });
+      mkdirSync(join(stage, 'node'), { recursive: true });
+      for (const name of ['package.json', 'package-lock.json']) writeFileSync(join(stage, 'node', name), readFileSync(join(runtimeRoot, name)));
+      run(env.LITHERMES_MOTION_NPM || 'npm', ['ci', '--prefix', join(stage, 'node'), '--omit=dev', '--ignore-scripts', '--no-audit', '--no-fund'],
+        { env: { ...env, npm_config_cache: join(dirname(cache), 'npm-cache') }, timeout: 600000 });
+      for (const entry of pins.entries) await fetchPinned(entry, join(stage, 'assets', entry.path), { mirror: env.LITHERMES_MOTION_FONT_MIRROR });
+      for (const pair of HANGUL_PAIR) {
+        const file = hangulPath(pair.file);
+        if (!existsSync(file) || sha(readFileSync(file)) !== pair.sha256) throw new Error(`reused Hangul font missing or changed: lit-pptx/${pair.file}`);
+      }
+      writeFileSync(join(stage, 'READY'), `${digest}\n`);
+      if (existing) rmSync(existing, { recursive: true, force: true });
+      rmSync(cache, { recursive: true, force: true });
+      renameSync(stage, cache);
+      receipts.push(`motion-runtime READY cache=${cache}`);
+    } finally {
+      rmSync(stage, { recursive: true, force: true });
+      closeSync(fd);
+      rmSync(lockPath, { force: true });
+    }
+  } else receipts.push(`motion-runtime READY cache=${cache} (already warm)`);
+  if (audio) receipts.push(audioState(env).state === 'ready' ? 'audio venv READY (already warm)' : await installAudio(findCache(env), env));
+  return receipts.join('\n');
+}
+
+const chromeProbeScript = () => {
+  const gl = document.createElement('canvas').getContext('webgl2');
+  if (!gl) return null;
+  const ext = gl.getExtension('WEBGL_debug_renderer_info');
+  return ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : 'unknown (debug-info extension unavailable)';
+};
+
+// MO-A-44: five probes on every run, in this product's "name: value" status style.
+export async function status(env = process.env) {
+  const { chromeExecutable, launchChrome } = await import('../engine/browser.mjs');
+  const { isSoftwareRenderer, UNKNOWN_RENDERER } = await import('../engine/constants.mjs');
+  const chrome = chromeExecutable(env);
+  const version = chrome ? spawnSync(chrome, ['--version'], { encoding: 'utf8', timeout: 10000 }).stdout?.trim() : '';
+  const ffmpeg = spawnSync('ffmpeg', ['-hide_banner', '-version'], { encoding: 'utf8', timeout: 10000, env });
+  let preview = 'none';
+  if (ffmpeg.status === 0) {
+    const encoders = spawnSync('ffmpeg', ['-hide_banner', '-encoders'], { encoding: 'utf8', timeout: 10000, env }).stdout || '';
+    preview = /libwebp_anim/.test(encoders) ? 'libwebp_anim'
+      : spawnSync('img2webp', ['-version'], { encoding: 'utf8', timeout: 10000, env }).status === 0 ? 'img2webp' : 'gif';
+  }
+  const deps = depState(env);
+  const fonts = fontState(env);
+  const audio = audioState(env);
+  let renderer = null, glLine;
+  if (!chrome) glLine = 'no WebGL2 context obtainable (Chrome not found)';
+  else if (!deps.ready) glLine = `not probed: pinned driver not pre-warmed (run \`${WARM}\`)`;
+  else {
+    const { mkdtempSync } = await import('node:fs');
+    const { tmpdir } = await import('node:os');
+    const profileRoot = mkdtempSync(join(tmpdir(), 'lhm-'));
+    try {
+      const launched = await launchChrome({ chromium: runtimeRequire(env)('playwright-core').chromium, profileRoot, env, timeoutMs: 25000 });
+      renderer = (await launched.page.evaluate(chromeProbeScript)) || launched.renderer;
+      glLine = `${renderer} (flags: ${launched.flags.join(' ')})`;
+      await launched.context.close().catch(() => {});
+    } catch (error) {
+      glLine = `no WebGL2 context obtainable: ${String(error.message).split('\n')[0]}`;
+    } finally { rmSync(profileRoot, { recursive: true, force: true }); }
+  }
+  const software = !renderer ? 'unknown (no renderer probed)'
+    : renderer === UNKNOWN_RENDERER ? 'warning: renderer type unknown - debug-info extension unavailable'
+      : isSoftwareRenderer(renderer) ? `warning: software GL detected (${renderer}); renders will be slower, --samples lowered automatically`
+        : 'none (hardware renderer)';
+  const warmParts = [];
+  if (!deps.ready) warmParts.push(`missing ${deps.missing.join(', ')}`);
+  if (fonts.missing.length) warmParts.push(`missing fonts/licences: ${fonts.missing.join(', ')}`);
+  if (fonts.mismatched.length) warmParts.push(`hash mismatch: ${fonts.mismatched.join(', ')}`);
+  const audioText = audio.state === 'ready' ? 'audio venv READY' : audio.state === 'mismatched'
+    ? `audio venv present but ${audio.detail || 'pins drifted'} (Tier 1 fallback; fix: ${WARM} --audio)` : `audio venv not installed (optional: ${WARM} --audio)`;
+  const warm = warmParts.length ? `NOT READY - ${warmParts.join('; ')}; fix: ${WARM}` : `READY cache=${deps.cache}`;
+  return [
+    `Chrome: ${chrome ? `${chrome} (${version || 'version unknown'})` : 'not found on PATH / not installed (set CHROME_PATH)'}`,
+    `ffmpeg: ${ffmpeg.status === 0 ? `${ffmpeg.stdout.split('\n')[0]}; preview encoder: ${preview}` : 'not found on PATH (video export blocked; stills and sheet still work)'}`,
+    `WebGL2 renderer: ${glLine}`,
+    `software GL: ${software}`,
+    `pre-warm: ${warm}; ${audioText}`,
+  ];
+}
+
+function isMain() {
+  try { return realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url)); } catch { return false; }
+}
+
+const USAGE = 'LitHermes motion-runtime usage: install|status [--audio] [--word-timing]';
+if (isMain()) {
+  const [action, ...rest] = process.argv.slice(2);
+  const flags = new Set(rest);
+  if (!action || action === '--help' || action === 'help') console.log(USAGE);
+  else if (action === 'status') {
+    console.log((await status()).join('\n'));
+    if (flags.has('--word-timing')) console.log(wordTimingPlan().lines.join('\n'));
+  } else if (action === 'install') {
+    try {
+      console.log(await install({ audio: flags.has('--audio'), wordTiming: flags.has('--word-timing') }));
+    } catch (error) {
+      console.error(String(error.message));
+      process.exitCode = error.exitCode || 1;
+    }
+  } else { console.error(USAGE); process.exitCode = 2; }
+}

package/assets/lithermes-plugin/skills/lit-typographic-motion/engine/NOTICE

@@ -0,0 +1,23 @@
+Portions of this engine are adapted from mexicat/pdoom-video
+(https://github.com/mexicat/pdoom-video), commit
+ca251e3dddda422b364385eb484b5a3593a0990d.
+
+Copyright (c) 2026 Giacomo Magnanini
+
+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/assets/lithermes-plugin/skills/lit-typographic-motion/engine/THIRD_PARTY_NOTICES

@@ -0,0 +1,55 @@
+LitHermes lit-typographic-motion: third-party notices
+
+Engine: portions adapted from mexicat/pdoom-video, commit
+ca251e3dddda422b364385eb484b5a3593a0990d (MIT, Giacomo Magnanini). The full
+MIT permission text is in engine/NOTICE next to this file.
+
+Fonts. Nothing below is bundled in this package. `lithermes motion-runtime
+install` fetches each file from its pinned URL, verifies its sha256 against
+runtime/fonts.json, and stores it with its licence file in the product cache.
+<cache> means that cache directory (printed by `lithermes motion-runtime status`).
+
+font: <cache>/assets/fonts/Galmuri9.ttf
+  licence: <cache>/assets/licenses/Galmuri-OFL.md (SIL OFL 1.1, Reserved Font Name; used unmodified)
+font: <cache>/assets/fonts/VT323-Regular.ttf
+  licence: <cache>/assets/licenses/VT323-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Silkscreen-Regular.ttf
+  licence: <cache>/assets/licenses/Silkscreen-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Silkscreen-Bold.ttf
+  licence: <cache>/assets/licenses/Silkscreen-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/MesloLGS-NF-Regular.ttf
+  licence: <cache>/assets/licenses/Meslo-Notice.txt (Apache-2.0 notice)
+  licence: <cache>/assets/licenses/Meslo-Apache.txt (Apache License 2.0 text)
+  licence: <cache>/assets/licenses/Meslo-Vera-Arev.txt (inherited Bitstream Vera and Arev notices)
+font: <cache>/assets/fonts/Archivo-w750-500.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w750-700.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w750-900.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w1000-500.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w1000-700.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w1000-900.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w1250-500.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w1250-700.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/Archivo-w1250-900.ttf
+  licence: <cache>/assets/licenses/Archivo-OFL.txt (SIL OFL 1.1)
+font: <cache>/assets/fonts/stroke/EMSAllure.svg
+  licence: runtime/licenses/EMS-OFL.txt and runtime/licenses/CREDITS (in this package)
+font: <cache>/assets/fonts/stroke/EMSFelix.svg
+  licence: runtime/licenses/EMS-OFL.txt and runtime/licenses/CREDITS (in this package)
+font: <cache>/assets/fonts/stroke/EMSOsmotron.svg
+  licence: runtime/licenses/EMS-OFL.txt and runtime/licenses/CREDITS (in this package)
+font: <cache>/assets/fonts/stroke/EMSReadability.svg
+  licence: runtime/licenses/EMS-OFL.txt and runtime/licenses/CREDITS (in this package)
+font: <cache>/assets/fonts/stroke/EMSTech.svg
+  licence: runtime/licenses/EMS-OFL.txt and runtime/licenses/CREDITS (in this package)
+font: ../lit-pptx/pretendard-font/public/static/PretendardGOV-Regular.otf (reused by path, unmodified)
+  licence: ../lit-pptx/fonts/PRETENDARD-OFL.txt (SIL OFL 1.1)
+font: ../lit-pptx/pretendard-font/public/static/PretendardGOV-Bold.otf (reused by path, unmodified)
+  licence: ../lit-pptx/fonts/PRETENDARD-OFL.txt (SIL OFL 1.1)

package/assets/lithermes-plugin/skills/lit-typographic-motion/engine/browser.mjs

@@ -0,0 +1,169 @@
+// Headless Chrome driver (the driver half of pdoom's scripts/render.ts, MIT,
+// see NOTICE). Chrome is launched over the pipe transport, so no control port
+// listens; frames leave the page over a WebSocket bound to 127.0.0.1:0
+// (MO-A-02 option 1) or, when listen() is refused, through a per-frame CDP
+// pull of the same readback buffer (the sanctioned variant). Each MO-A-51 rung
+// counts only after a real getContext('webgl2') in the page.
+import { existsSync, lstatSync, mkdirSync, readdirSync, readlinkSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { EXIT, UNKNOWN_RENDERER, chromeFlagLadder, isSoftwareRenderer } from './constants.mjs';
+
+export const blocked = (code, message) => Object.assign(new Error(message), { exitCode: code });
+
+const CHROME_CANDIDATES = [
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable', '/usr/bin/chromium', '/usr/bin/chromium-browser',
+];
+
+export function chromeExecutable(env = process.env) {
+  if (env.CHROME_PATH) return existsSync(env.CHROME_PATH) ? env.CHROME_PATH : null;
+  return CHROME_CANDIDATES.find((candidate) => existsSync(candidate)) || null;
+}
+
+// The launcher's first line that names a cause. Crashpad's own complaints are
+// a side effect of a failed launch, never the cause, so they rank last.
+export function launchCause(error) {
+  const lines = String(error?.message || error).split('\n').map((line) => line.replace(/\x1b\[[0-9;]*m/g, '').trim()).filter(Boolean);
+  const strong = /sandbox initialization failed|Failed to initialize sandbox|error while loading shared|cannot open shared object|No usable sandbox|Permission denied|EACCES|ENOENT|spawn .* (?:ENOENT|EACCES)|Executable doesn't exist/i;
+  const hit = lines.find((line) => strong.test(line) && !/Crashpad/i.test(line));
+  if (hit) return hit.replace(/^-\s*(?:\[pid=\d+\])?(?:\[err\])?\s*/, '');
+  const err = lines.find((line) => /\[err\]/.test(line) && !/Crashpad/i.test(line));
+  if (err) return err.replace(/^-\s*(?:\[pid=\d+\])?(?:\[err\])?\s*/, '');
+  return lines[0] || 'unknown launch failure';
+}
+
+const probeScript = () => {
+  const canvas = document.createElement('canvas');
+  const gl = canvas.getContext('webgl2');
+  if (!gl) return { webgl2: false, renderer: null };
+  const ext = gl.getExtension('WEBGL_debug_renderer_info');
+  return { webgl2: true, renderer: ext ? gl.getParameter(ext.UNMASKED_RENDERER_WEBGL) : null };
+};
+
+// Walk the flag ladder; returns { context, page, flags, renderer } or throws 10/11.
+export async function launchChrome({ chromium, profileRoot, forceSoftware = false, platform = process.platform, env = process.env, timeoutMs = 30000 }) {
+  const chrome = chromeExecutable(env);
+  if (!chrome) throw blocked(EXIT.BLOCKED_NO_CHROME, 'BLOCKED_NO_CHROME: Chrome/Chromium not found; install Chrome or set CHROME_PATH');
+  const ladder = chromeFlagLadder(platform);
+  const rungs = forceSoftware ? ladder.slice(-1) : ladder;
+  const attempts = [];
+  let launchedWithoutWebgl = null;
+  mkdirSync(profileRoot, { recursive: true });
+  for (let i = 0; i < rungs.length; i++) {
+    const flags = rungs[i];
+    const profile = join(profileRoot, `p${i}`);
+    let context = null;
+    try {
+      context = await chromium.launchPersistentContext(profile, {
+        executablePath: chrome, headless: true, chromiumSandbox: true, args: flags, timeout: timeoutMs,
+        viewport: { width: 1920, height: 1080 }, deviceScaleFactor: 1,
+      });
+      const page = context.pages()[0] || await context.newPage();
+      const probe = await page.evaluate(probeScript);
+      if (probe.webgl2) {
+        return { context, page, flags, profile, chrome, renderer: probe.renderer || UNKNOWN_RENDERER, attempts };
+      }
+      launchedWithoutWebgl = `Chrome launched with ${flags[0]} but canvas.getContext('webgl2') returned null`;
+      attempts.push({ flags, result: 'no-webgl2' });
+    } catch (error) {
+      attempts.push({ flags, result: 'launch-failed', cause: launchCause(error) });
+    }
+    await context?.close().catch(() => {});
+    rmSync(profile, { recursive: true, force: true });
+  }
+  if (launchedWithoutWebgl) throw blocked(EXIT.BLOCKED_NO_WEBGL2, `BLOCKED_NO_WEBGL2: ${launchedWithoutWebgl}`);
+  const cause = attempts.find((a) => a.cause)?.cause || 'Chrome did not start';
+  throw blocked(EXIT.BLOCKED_NO_CHROME, `BLOCKED_NO_CHROME: headless Chrome failed to launch on every rung (${rungs.map((r) => r[0]).join(', ')}): ${cause}`);
+}
+
+// Unix sockets Chrome left in the profile (or behind its symlinks) and their path lengths.
+export function profileSockets(profile) {
+  const out = [];
+  const visit = (dir, depth) => {
+    if (depth > 2 || !existsSync(dir)) return;
+    for (const name of readdirSync(dir)) {
+      const path = join(dir, name);
+      let st;
+      try { st = lstatSync(path); } catch { continue; }
+      if (st.isSocket()) out.push({ path, bytes: Buffer.byteLength(path) });
+      else if (st.isSymbolicLink() && /Singleton/.test(name)) {
+        const target = readlinkSync(path);
+        if (target.startsWith('/')) out.push({ path: target, bytes: Buffer.byteLength(target), via: path });
+      } else if (st.isDirectory()) visit(path, depth + 1);
+    }
+  };
+  visit(profile, 0);
+  return out;
+}
+
+export async function openRenderer({ runtime, pageScript, profileRoot, scale = 1, forceSoftware = false, env = process.env }) {
+  const { chromium } = runtime('playwright-core');
+  const launched = await launchChrome({ chromium, profileRoot, forceSoftware, env });
+  const { context, page } = launched;
+  page.setDefaultTimeout(0);
+  await page.addScriptTag({ path: pageScript });
+  const setup = await page.evaluate((config) => window.motionSetup(config), { width: 1920, height: 1080, scale });
+  if (!setup.webgl2 || setup.error) {
+    await context.close().catch(() => {});
+    throw blocked(EXIT.BLOCKED_NO_WEBGL2, `BLOCKED_NO_WEBGL2: ${setup.error || 'no WebGL2 context in the render page'} (renderer: ${setup.renderer || launched.renderer})`);
+  }
+  const renderer = setup.renderer || launched.renderer;
+  const sockets = profileSockets(launched.profile);
+  let server = null, egress = 'websocket', listenError = null, pending = null;
+  try {
+    const { WebSocketServer } = runtime('ws');
+    if (env.LITHERMES_MOTION_FAULT_LISTEN) {
+      throw Object.assign(new Error(`listen ${env.LITHERMES_MOTION_FAULT_LISTEN}: operation not permitted 127.0.0.1:0 (injected)`), { code: env.LITHERMES_MOTION_FAULT_LISTEN });
+    }
+    server = new WebSocketServer({ host: '127.0.0.1', port: 0, maxPayload: 1920 * 1080 * 4 * scale * scale + 1024 });
+    await new Promise((resolve, reject) => { server.once('listening', resolve); server.once('error', reject); });
+    server.on('connection', (socket) => {
+      socket.on('message', (data) => {
+        const current = pending;
+        pending = null;
+        current?.resolve(Buffer.isBuffer(data) ? data : Buffer.from(data));
+      });
+    });
+    await page.evaluate((port) => window.motionConnect(port), server.address().port);
+  } catch (error) {
+    listenError = `${error.code || 'error'}: ${String(error.message).split('\n')[0]}`;
+    try { server?.close(); } catch {}
+    server = null;
+    egress = 'cdp-pull';
+  }
+  let lastFrame = null;
+  return {
+    renderer, flags: launched.flags, software: isSoftwareRenderer(renderer), egress, listenError, sockets, attempts: launched.attempts,
+    get lastFrame() { return lastFrame; },
+    async frame(spec) {
+      spec.egress = egress;
+      if (spec.prime) {
+        await page.evaluate((s) => window.motionFrame(s), spec);
+        lastFrame = spec.frame;
+        return null;
+      }
+      if (server) {
+        const bytes = new Promise((resolve, reject) => { pending = { resolve, reject }; });
+        const meta = await page.evaluate((s) => window.motionFrame(s), spec);
+        lastFrame = spec.frame;
+        return { bytes: await bytes, meta };
+      }
+      let meta;
+      try {
+        meta = await page.evaluate((s) => window.motionFrame(s), spec);
+      } catch (error) {
+        throw blocked(EXIT.BLOCKED_NO_WEBGL2, `frame egress failed after listen was refused (${listenError}): ${String(error.message).split('\n')[0]}`);
+      }
+      lastFrame = spec.frame;
+      const bytes = Buffer.from(meta.rgbaBase64, 'base64');
+      delete meta.rgbaBase64;
+      return { bytes, meta };
+    },
+    async close() {
+      try { server?.close(); } catch {}
+      await context.close().catch(() => {});
+      rmSync(launched.profile, { recursive: true, force: true });
+    },
+  };
+}

package/assets/lithermes-plugin/skills/lit-typographic-motion/engine/completion.mjs

@@ -0,0 +1,52 @@
+// When a motion turn counts as done (the route contract's completion rule).
+// Only a completed, verified render counts: the manifest and gate report are
+// newer than the last brief edit, and either the gate passed with all four
+// artifacts delivered, or round 3 of 3 ended in exit 13 with the artifacts in
+// the place the failure demands (delivered for an ordinary failure, withheld
+// for a flash failure). Started, stills-only, BLOCKED or silent runs never count.
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ARTIFACTS = ['film.mp4', 'poster.png', 'reduced-motion.png'];
+const previewName = (dir) => ['preview.webp', 'preview.gif'].find((name) => existsSync(join(dir, name)));
+const no = (reason) => ({ done: false, reason });
+
+export function checkCompletion(out) {
+  const statePath = join(out, 'run-state.json');
+  if (!existsSync(statePath)) return no('no run-state.json: the render command never finished');
+  const state = JSON.parse(readFileSync(statePath, 'utf8'));
+  if (state.exitCode === null || state.exitCode === undefined || !state.finished) return no('the render command started but did not finish');
+  if (state.mode === 'stills-only' || state.mode === 'stills' || state.mode === 'sheet') return no('a stills-only look pass is not a delivered film');
+  if ([10, 11, 12, 14, 15].includes(state.exitCode)) return no(`BLOCKED exit ${state.exitCode}: fix the named prerequisite and rerun`);
+  if (state.exitCode !== 0 && state.exitCode !== 13) return no(`the command exited ${state.exitCode}`);
+  const manifestPath = join(out, 'manifest.json'), reportPath = join(out, 'gate-report.txt');
+  if (!existsSync(manifestPath)) return no('manifest.json is missing');
+  if (!existsSync(reportPath)) return no('gate-report.txt is missing');
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+  const brief = manifest.lithermes?.brief;
+  if (!brief?.path || !existsSync(brief.path)) return no('the manifest does not name an existing brief');
+  const briefTime = statSync(brief.path).mtimeMs;
+  if (statSync(manifestPath).mtimeMs < briefTime || statSync(reportPath).mtimeMs < briefTime) return no('the brief changed after the last render; rerun');
+  if (createHash('sha256').update(readFileSync(brief.path)).digest('hex') !== brief.sha256) return no('the brief no longer matches the rendered one; rerun');
+  const report = readFileSync(reportPath, 'utf8');
+  const failed = state.failed || [];
+  const flash = failed.includes('MO-C-03');
+  const delivered = ARTIFACTS.every((name) => existsSync(join(out, name))) && previewName(out);
+  const withheldDir = join(out, 'withheld');
+  const withheld = ARTIFACTS.every((name) => existsSync(join(withheldDir, name))) && previewName(withheldDir);
+  if (state.exitCode === 0) {
+    if (!/QA gate: PASS/.test(report)) return no('exit 0 without a passing gate report');
+    return delivered ? { done: true, reason: 'gate passed; four artifacts delivered' } : no('gate passed but an artifact is missing from its deliverable name');
+  }
+  if ((state.round ?? manifest.lithermes?.round ?? 1) < 3) return no(`gate failed in round ${state.round}; fix the named rules and rerun with --round ${(state.round || 1) + 1}`);
+  if (flash) {
+    if (delivered || ['film.mp4', 'poster.png', 'preview.webp', 'preview.gif'].some((name) => existsSync(join(out, name)))) return no('a flash-failing export sits at a deliverable name');
+    if (!withheld) return no('flash failure without the exports in withheld/');
+    if (!/WITHHELD/.test(report)) return no('the report does not say the render is withheld');
+    return { done: true, reason: 'round 3 flash failure: exports withheld pending a fix' };
+  }
+  if (!delivered) return no('round 3 failure but the artifacts are not at their deliverable names');
+  if (!failed.length || !failed.every((id) => report.includes(id))) return no('the report does not name the failed rules');
+  return { done: true, reason: `round 3 ended with ${failed.join(', ')} failing; artifacts delivered with the report` };
+}