@kaydash9999/banker-plugins 0.26.1 → 0.28.0

package/skills/video-gen/scripts/vg-scenes.mjs

@@ -0,0 +1,226 @@
+// vg-scenes.mjs: one draw function per scene type. Each draws the scene at local time t (0 .. duration) on a
+// Painter, from the scene and the theme only, so any frame can be drawn on its own. Every scene clears the frame
+// first, and entrances fit the scene's length (gaps shrink, then starts and effect lengths scale), so everything is
+// shown at rest before the scene ends, however short.
+import { clamp, counter, decimals, ease, fitGap, grouped, lerp, smooth, stagger } from "./vg-fx.mjs";
+import { PALETTE } from "./vg-model.mjs";
+
+const enter = (t, at = 0, dur = 0.6) => ease.outCubic(clamp((t - at) / dur));
+const margin = (P) => Math.round(P.W * 0.08);
+// Entrances finish this long before the scene ends, so its last moment shows everything at rest.
+const REST = 0.3;
+/** 1 when entrances that take `base` seconds fit before REST, less in a shorter scene: starts and lengths scale by it. */
+const pace = (duration, base) => Math.min(1, (duration - REST) / base);
+// Splits text into what a reader sees as characters (a Hangul syllable, an emoji with its skin tone).
+const SEG = typeof Intl !== "undefined" && Intl.Segmenter ? new Intl.Segmenter("ko", { granularity: "grapheme" }) : null;
+export const graphemes = (s) => (SEG ? Array.from(SEG.segment(s), (x) => x.segment) : Array.from(s));
+
+/** The heading and its accent bar; returns the y below them (the real heading height, two lines included). */
+function heading(P, th, title, t, k = 1) {
+  const m = margin(P);
+  const a = enter(t, 0.1 * k, 0.6 * k);
+  const top = m * 0.8;
+  const h = P.text(title, m, top + (1 - a) * 20 * P.u, { size: 44 * P.u, bold: true, color: th.fg, width: P.W - 2 * m }, { alpha: a }).h;
+  P.rect(m, top + h + 8 * P.u, 110 * P.u * enter(t, 0.3 * k, 0.6 * k), 6 * P.u, th.accent);
+  return top + h + 40 * P.u;
+}
+
+function title(P, s, th, t) {
+  P.clear(th.bg);
+  const m = margin(P);
+  const cy = P.H * 0.46;
+  const k = pace(s.duration, 1.5);
+  P.rect(m, cy - 18 * P.u, P.W * 0.18 * enter(t, 0.2 * k, 0.8 * k), 8 * P.u, th.accent);
+  const a = stagger(t, 0, { start: 0.35 * k, dur: 0.7 * k, curve: ease.outBack });
+  const h = P.text(s.title, m, cy + (1 - clamp(a)) * 40 * P.u, { size: 64 * P.u, bold: true, color: th.fg, width: P.W - 2 * m }, { alpha: clamp(a) }).h;
+  if (s.subtitle) P.text(s.subtitle, m, cy + h + 18 * P.u, { size: 30 * P.u, color: th.muted, width: P.W - 2 * m }, { alpha: enter(t, 0.9 * k, 0.6 * k) });
+}
+
+/** Lines whose characters enter one by one (stagger with an outBack overshoot), centred. */
+function kinetic(P, s, th, t) {
+  P.clear(th.bg);
+  const size = (s.lines.length > 3 ? 56 : 76) * P.u;
+  const lh = size * 1.35;
+  const lines = s.lines.map(graphemes);
+  const total = lines.reduce((n, l) => n + l.length, 0);
+  const k = pace(s.duration, 0.7);
+  const gap = fitGap(total, 0.06, 0.2 * k, 0.5 * k, s.duration - REST);
+  let y = P.H / 2 - (lines.length * lh) / 2;
+  let i = 0;
+  lines.forEach((chars, li) => {
+    const widths = chars.map((ch) => P.measure(ch, { size, bold: true }).w);
+    let x = (P.W - widths.reduce((a, b) => a + b, 0)) / 2;
+    chars.forEach((ch, c) => {
+      const p = stagger(t, i++, { start: 0.2 * k, gap, dur: 0.5 * k, curve: ease.outBack });
+      const color = li === lines.length - 1 && c === chars.length - 1 ? th.accent : th.fg;
+      if (ch.trim()) P.text(ch, x, y + (1 - p) * 0.4 * size, { size, bold: true, color }, { alpha: clamp(p * 1.4), scale: lerp(0.6, 1, clamp(p)) });
+      x += widths[c];
+    });
+    y += lh;
+  });
+}
+
+function bullets(P, s, th, t) {
+  P.clear(th.bg);
+  const m = margin(P);
+  const k = pace(s.duration, 1.2);
+  let y = heading(P, th, s.title, t, k);
+  const size = 32 * P.u;
+  const gap = fitGap(s.bullets.length, 0.35, 0.6 * k, 0.6 * k, s.duration - REST);
+  s.bullets.forEach((b, i) => {
+    const p = stagger(t, i, { start: 0.6 * k, gap, dur: 0.6 * k });
+    P.circle(m + 10 * P.u, y + size * 0.62, 7 * P.u * p, th.accent);
+    const h = P.text(b, m + 34 * P.u + (1 - p) * 40 * P.u, y, { size, color: th.fg, width: P.W - 2 * m - 34 * P.u }, { alpha: p }).h;
+    y += h + 16 * P.u;
+  });
+}
+
+function chart(P, s, th, t) {
+  P.clear(th.bg);
+  const m = margin(P);
+  const top = heading(P, th, s.title, t, pace(s.duration, 1.2)) + 30 * P.u;
+  const box = { x: m + 60 * P.u, y: top, w: P.W - 2 * m - 60 * P.u, h: Math.max(40 * P.u, P.H - top - m - 40 * P.u) };
+  const all = s.chart.series.flatMap((x) => x.values);
+  const hi = all.reduce((a, b) => Math.max(a, b), 0);
+  const lo = all.reduce((a, b) => Math.min(a, b), 0);
+  const y = (v) => box.y + box.h - ((v - lo) / (hi - lo || 1)) * box.h;
+  P.line([[box.x, y(0)], [box.x + box.w, y(0)]], th.muted, 2 * P.u, 0.6);
+  const slot = box.w / s.chart.labels.length;
+  s.chart.labels.forEach((l, i) => P.text(l, box.x + slot * i, box.y + box.h + 10 * P.u, { size: 18 * P.u, color: th.muted, width: slot, align: "center" }));
+  const geo = { box, y, slot, d: decimals(all), end: s.duration - REST };
+  if (s.chart.kind === "line") lineSeries(P, s, t, geo);
+  else barSeries(P, s, th, t, geo);
+  legend(P, s, th, box);
+}
+
+function barSeries(P, s, th, t, { y, box, slot, d, end }) {
+  const n = s.chart.series.length;
+  const bw = (slot * 0.7) / n;
+  const count = s.chart.labels.length;
+  // The first bar starts at `from` and grows for `dur`; both scale so a bar fits a short scene, then the series and
+  // label gaps shrink so the last bar is full by `end`.
+  const q = Math.min(1, end / 1.4);
+  const from = 0.6 * q;
+  const dur = 0.8 * q;
+  const k0 = fitGap(n, 0.15, from, dur + 0.08 * (count - 1), end);
+  const gap = fitGap(count, 0.08, from + k0 * (n - 1), dur, end);
+  s.chart.series.forEach((ser, k) => ser.values.forEach((v, i) => {
+    const p = stagger(t, i, { start: from + k * k0, gap, dur });
+    const top = lerp(y(0), y(v), p);
+    const x = box.x + slot * i + slot * 0.15 + bw * k;
+    P.rect(x, Math.min(top, y(0)), bw * 0.92, Math.abs(y(0) - top), PALETTE[k % PALETTE.length]);
+    const label = p >= 1 ? grouped(v, d) : grouped(v * p, d);
+    if (p > 0.05 && v !== 0) P.text(label, x - 20 * P.u, Math.min(top, y(0)) - 26 * P.u, { size: 16 * P.u, color: th.fg, width: bw + 40 * P.u, align: "center" }, { alpha: p, transient: p < 1 });
+  }));
+}
+
+function lineSeries(P, s, t, { y, box, slot, end }) {
+  const from = Math.min(0.6, end * 0.4);
+  const draw = Math.min(1.6, end - from);
+  const dot = Math.min(0.3, draw);
+  const p = enter(t, from, draw);
+  s.chart.series.forEach((ser, k) => {
+    const pts = ser.values.map((v, i) => [box.x + slot * (i + 0.5), y(v)]);
+    const color = PALETTE[k % PALETTE.length];
+    P.clip(box.x - 10, box.y - 20 * P.u, (box.w + 20) * p, box.h + 40 * P.u, () => P.line(pts, color, 5 * P.u));
+    const gap = fitGap(pts.length, draw / pts.length, from, dot, end);
+    pts.forEach((q, i) => P.circle(q[0], q[1], 8 * P.u * stagger(t, i, { start: from, gap, dur: dot, curve: ease.outBack }), color));
+  });
+}
+
+function legend(P, s, th, box) {
+  if (s.chart.series.length < 2 && !s.chart.unit) return;
+  let x = box.x;
+  const yy = box.y - 34 * P.u;
+  if (s.chart.unit) x += P.text(`(${s.chart.unit})`, x, yy, { size: 16 * P.u, color: th.muted }).w + 24 * P.u;
+  if (s.chart.series.length < 2) return;
+  s.chart.series.forEach((ser, k) => {
+    P.rect(x, yy + 4 * P.u, 16 * P.u, 16 * P.u, PALETTE[k % PALETTE.length]);
+    x += 24 * P.u + P.text(ser.name, x + 24 * P.u, yy, { size: 16 * P.u, color: th.fg }).w + 24 * P.u;
+  });
+}
+
+/** A big number that rolls from `from` to `to` (with their decimal places), its label above and unit after. */
+function count(P, s, th, t) {
+  P.clear(th.bg);
+  const d = decimals([s.from, s.to]);
+  const start = Math.min(0.4, s.duration * 0.15);
+  const roll = Math.max(0.1, s.duration - REST - start);
+  const v = counter(t, s.from, s.to, start, roll, d);
+  const k = pace(s.duration, 0.8);
+  const unit = s.unit ? ` ${s.unit}` : "";
+  const size = 120 * P.u;
+  if (s.label) P.text(s.label, 0, P.H / 2 - size * 0.9, { size: 30 * P.u, color: th.muted, width: P.W, align: "center" }, { alpha: enter(t, 0.1 * k, 0.6 * k) });
+  const h = P.text(`${grouped(v, d)}${unit}`, 0, P.H / 2 - size * 0.45, { size, bold: true, color: th.fg, width: P.W, align: "center" }, { alpha: enter(t, 0.2 * k, 0.6 * k), transient: v !== s.to }).h;
+  const mw = Math.min(P.W, P.measure(`${grouped(s.to, d)}${unit}`, { size, bold: true }).w);
+  P.rect((P.W - mw) / 2, P.H / 2 - size * 0.45 + h + 6 * P.u, mw * enter(t, start, roll), 6 * P.u, th.accent);
+}
+
+/** A name strap: the accent plate leads, the dark bar follows, the name rises inside it, then all rewind out. */
+function lowerthird(P, s, th, t) {
+  P.clear(th.bg);
+  if (s.image) P.image(s.image, { x: 0, y: 0, w: P.W, h: P.H }, { zoom: lerp(1, 1.06, t / s.duration) });
+  const outAt = Math.max(s.duration * 0.6, s.duration - 0.7);
+  const out = smooth((t - outAt) / Math.min(0.6, s.duration - outAt));
+  const m = margin(P);
+  const nameSize = 34 * P.u;
+  const name = P.measure(s.name, { size: nameSize, bold: true, width: P.W * 0.7 });
+  const role = s.role ? P.measure(s.role, { size: 20 * P.u, width: P.W * 0.7 }) : { w: 0, h: 0 };
+  const w = Math.max(name.w, role.w) + 60 * P.u;
+  const h = name.h + role.h + 40 * P.u;
+  const y = P.H - m - h;
+  const k = Math.min(1, outAt / 1.5);
+  const plate = enter(t, 0.2 * k, 0.5 * k) * (1 - out);
+  const bar = enter(t, 0.35 * k, 0.55 * k) * (1 - out);
+  P.rect(m - 12 * P.u, y, 12 * P.u + w * plate, h, th.accent);
+  P.rect(m, y, w * bar, h, th.ink, 0.92);
+  P.clip(m, y, w * bar, h, () => {
+    const rise = enter(t, 0.6 * k, 0.5 * k) * (1 - out);
+    P.text(s.name, m + 30 * P.u, y + 18 * P.u + (1 - rise) * h, { size: nameSize, bold: true, color: "FFFFFF", width: P.W * 0.7 });
+    if (s.role) P.text(s.role, m + 30 * P.u, y + 22 * P.u + name.h + (1 - enter(t, 0.8 * k, 0.5 * k) * (1 - out)) * h, { size: 20 * P.u, color: th.muted, width: P.W * 0.7 });
+  });
+  P.rect(m + 30 * P.u, y + h - 12 * P.u, name.w * enter(t, k, 0.5 * k) * (1 - out), 4 * P.u, th.accent);
+}
+
+function quote(P, s, th, t) {
+  P.clear(th.bg);
+  const m = margin(P);
+  const k = pace(s.duration, 2);
+  const pop = stagger(t, 0, { start: 0.1 * k, dur: 0.6 * k, curve: ease.outBack });
+  P.text("“", m, P.H * 0.18, { size: 160 * P.u, bold: true, color: th.accent }, { alpha: clamp(pop), scale: lerp(0.4, 1, clamp(pop)) });
+  const a = enter(t, 0.5 * k, 0.8 * k);
+  const h = P.text(s.quote, m + 20 * P.u, P.H * 0.36 + (1 - a) * 30 * P.u, { size: 44 * P.u, bold: true, color: th.fg, width: P.W - 2 * m - 40 * P.u }, { alpha: a }).h;
+  if (s.by) P.text(`- ${s.by}`, m, P.H * 0.36 + h + 30 * P.u, { size: 26 * P.u, color: th.muted, width: P.W - 2 * m, align: "right" }, { alpha: enter(t, 1.2 * k, 0.6 * k) });
+}
+
+function image(P, s, th, t) {
+  P.clear("000000");
+  const k = t / s.duration;
+  const opts = s.motion === "pan" ? { zoom: 1.12, pan: lerp(-1, 1, k) } : { zoom: lerp(1, 1.1, k) };
+  P.image(s.image, { x: 0, y: 0, w: P.W, h: P.H }, opts);
+  if (!s.caption) return;
+  const m = margin(P);
+  const q = pace(s.duration, 1);
+  const a = enter(t, 0.4 * q, 0.6 * q);
+  const size = 26 * P.u;
+  const c = P.measure(s.caption, { size, width: P.W - 2 * m - 40 * P.u });
+  P.rect(m, P.H - m - c.h - 30 * P.u, Math.min(P.W - 2 * m, c.w + 40 * P.u), c.h + 30 * P.u, th.ink, 0.8 * a);
+  P.text(s.caption, m + 20 * P.u, P.H - m - c.h - 15 * P.u, { size, color: "FFFFFF", width: P.W - 2 * m - 40 * P.u }, { alpha: a });
+}
+
+/** Credits rolling up from below the frame to above it over the scene. */
+function credits(P, s, th, t) {
+  P.clear(th.bg);
+  const size = 30 * P.u;
+  const gap = size * 0.7;
+  const items = [...(s.title ? [{ text: s.title, bold: true, size: size * 1.4 }] : []), ...s.lines.map((l) => ({ text: l, bold: false, size }))];
+  const heights = items.map((it) => P.measure(it.text, { size: it.size, bold: it.bold, width: P.W * 0.8, align: "center" }).h);
+  const total = heights.reduce((a, b) => a + b + gap, 0);
+  let y = lerp(P.H, -total, clamp(t / s.duration));
+  items.forEach((it, i) => {
+    if (y + heights[i] > 0 && y < P.H) P.text(it.text, P.W * 0.1, y, { size: it.size, bold: it.bold, color: it.bold ? th.accent : th.fg, width: P.W * 0.8, align: "center" });
+    y += heights[i] + gap;
+  });
+}
+
+export const DRAW = { title, kinetic, bullets, chart, counter: count, lowerthird, quote, image, credits };

package/skills/video-gen/scripts/video-gen.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * video-gen.mjs: the helper the video-gen skill runs. It turns a scene file (JSON) into an H.264 MP4 with the
+ * bundled engine (Skia CanvasKit and an H.264 encoder, both WASM, plus Noto fonts): no Chrome, no ffmpeg, no
+ * install, no network.
+ *
+ *   node video-gen.mjs list                                     what can be made (built in, or which skill)
+ *   node video-gen.mjs example                                  print a sample scene file (JSON)
+ *   node video-gen.mjs from-deck --deck <deck.json>             a wide-pptx deck as a scene file (JSON on stdout)
+ *   node video-gen.mjs check --scene <scene.json>
+ *   node video-gen.mjs still --scene <scene.json> --at <seconds> --out <file.png> [--force]
+ *   node video-gen.mjs render --scene <scene.json> --out <file.mp4> [--quality <10-51>] [--force]
+ *
+ * - Image paths in the scene file are local files, relative to its folder.
+ * - render prints progress on stderr about once a second, then `WROTE <path>` and `OK ...` on stdout.
+ * - Outputs are written through a random temporary name; a hard link (or an exclusive copy) puts it in place, so
+ *   an existing file is never replaced without --force.
+ *
+ * Exit status: 0 done, 1 the scene file has errors, 2 usage error or a file that could not be read or written.
+ */
+import { randomBytes } from "node:crypto";
+import { constants, copyFileSync, linkSync, lstatSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { catalogText } from "./vg-catalog.mjs";
+import { deckToScenes } from "./vg-deck.mjs";
+import { readScenes, sceneBase } from "./vg-model.mjs";
+import { layoutWarnings, probeImages, renderMp4, renderStill } from "./vg-render.mjs";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const EXAMPLE = join(HERE, "..", "assets", "example.json");
+
+class Usage extends Error {}
+
+const isDir = (p) => {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+export function parseArgs(argv, bools = ["force"]) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) {
+      out._.push(a);
+      continue;
+    }
+    const name = a.slice(2);
+    if (bools.includes(name)) {
+      out[name] = true;
+      continue;
+    }
+    const v = argv[++i];
+    if (v === undefined || v.startsWith("--")) throw new Usage(`--${name} 에 값이 없음`);
+    out[name] = v;
+  }
+  return out;
+}
+
+function readJson(file, what) {
+  if (!file) throw new Usage(`--${what} <파일.json> 이 필요함`);
+  try {
+    return JSON.parse(readFileSync(file, "utf8").replace(/^\uFEFF/, ""));
+  } catch (e) {
+    throw new Usage(`${what} 을 읽지 못함: ${e.message}`);
+  }
+}
+
+/** Reads and checks the scene file, decodes its images and measures its text; null when it has errors. */
+async function loadScenes(args) {
+  const res = readScenes(readJson(args.scene, "scene"), sceneBase(args.scene));
+  const errors = [...res.errors];
+  const warnings = [...res.warnings];
+  if (res.model) errors.push(...(await probeImages(res.model)));
+  if (res.model && !errors.length) warnings.push(...(await layoutWarnings(res.model)));
+  for (const w of warnings) process.stderr.write(`경고: ${w}\n`);
+  for (const e of errors) process.stderr.write(`오류: ${e}\n`);
+  return errors.length ? null : res.model;
+}
+
+const summary = (m) => `장면 ${m.scenes.length}, ${m.duration.toFixed(1)}초, ${m.width}x${m.height}, ${m.fps}fps, 프레임 ${m.frames}`;
+
+/** Checks the output path before any work: extension, folder, and (without --force) an existing file. */
+function target(args, ext) {
+  if (!args.out) throw new Usage(`--out <파일${ext}> 이 필요함`);
+  const p = resolve(args.out);
+  if (extname(p).toLowerCase() !== ext) throw new Usage(`--out 은 ${ext} 이어야 함`);
+  if (!isDir(dirname(p))) throw new Usage(`출력 폴더가 없음: ${dirname(p)}`);
+  let st = null;
+  try {
+    st = lstatSync(p);
+  } catch {
+    // nothing there yet
+  }
+  if (st && !args.force) throw new Usage(`이미 있음(덮어쓰려면 --force): ${p}`);
+  if (st && !st.isFile()) throw new Usage(`보통 파일이 아니라 덮어쓰지 않음: ${p}`);
+  return p;
+}
+
+function copyExclusive(tmp, dest) {
+  try {
+    copyFileSync(tmp, dest, constants.COPYFILE_EXCL);
+  } catch (e) {
+    if (e.code !== "EEXIST") rmSync(dest, { force: true });
+    throw e;
+  }
+}
+
+function writeOut(dest, data, force) {
+  const tmp = join(dirname(dest), `.${randomBytes(6).toString("hex")}.video-gen.tmp`);
+  try {
+    writeFileSync(tmp, data, { flag: "wx" });
+    if (force) renameSync(tmp, dest);
+    else {
+      try {
+        linkSync(tmp, dest);
+      } catch (e) {
+        if (e.code === "EEXIST") throw e;
+        copyExclusive(tmp, dest);
+      }
+      rmSync(tmp, { force: true });
+    }
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw new Usage(`쓰지 못함 ${dest}: ${e.code === "EEXIST" ? "이미 있음(덮어쓰려면 --force)" : e.message}`);
+  }
+  return dest;
+}
+
+async function cmdRender(args) {
+  const dest = target(args, ".mp4");
+  const quality = args.quality === undefined ? 20 : Number(args.quality);
+  if (!Number.isInteger(quality) || quality < 10 || quality > 51) throw new Usage("--quality 는 10~51 정수(작을수록 고화질)");
+  const model = await loadScenes(args);
+  if (!model) return 1;
+  let last = 0;
+  const onFrame = (i, n) => {
+    if (Date.now() - last < 1000 && i < n) return;
+    last = Date.now();
+    process.stderr.write(`프레임 ${i}/${n}\n`);
+  };
+  const { bytes, frames } = await renderMp4(model, { quality, onFrame });
+  process.stdout.write(`WROTE ${writeOut(dest, bytes, args.force)}\nOK ${summary(model)}, 기록 ${frames}, ${(bytes.length / 1048576).toFixed(1)}MB\n`);
+  return 0;
+}
+
+/** A still is a video frame: --at is snapped to the frame grid, and a time past the video is an error. */
+async function cmdStill(args) {
+  const dest = target(args, ".png");
+  const at = Number(args.at);
+  if (!Number.isFinite(at) || at < 0) throw new Usage("--at <초> 는 0 이상 숫자");
+  const model = await loadScenes(args);
+  if (!model) return 1;
+  if (at >= model.duration) throw new Usage(`--at 은 영상 길이(${model.duration}초)보다 짧아야 함`);
+  const frame = Math.min(model.frames - 1, Math.round(at * model.fps));
+  process.stdout.write(`WROTE ${writeOut(dest, await renderStill(model, frame / model.fps), args.force)}\nFRAME ${frame} (${(frame / model.fps).toFixed(3)}초)\n`);
+  return 0;
+}
+
+async function cmdCheck(args) {
+  const model = await loadScenes(args);
+  if (!model) return 1;
+  process.stdout.write(`OK ${summary(model)}\n`);
+  return 0;
+}
+
+function cmdFromDeck(args) {
+  const { scenes, skipped } = deckToScenes(readJson(args.deck, "deck"), dirname(resolve(args.deck)));
+  for (const s of skipped) process.stderr.write(`경고: ${s}\n`);
+  process.stdout.write(`${JSON.stringify(scenes, null, 2)}\n`);
+  return 0;
+}
+
+const COMMANDS = {
+  list: () => (process.stdout.write(catalogText()), 0),
+  example: () => (process.stdout.write(readFileSync(EXAMPLE, "utf8")), 0),
+  "from-deck": cmdFromDeck,
+  check: cmdCheck,
+  still: cmdStill,
+  render: cmdRender,
+};
+
+export async function main(argv) {
+  const [cmd, ...rest] = argv;
+  const run = Object.prototype.hasOwnProperty.call(COMMANDS, cmd) ? COMMANDS[cmd] : null;
+  if (!run) throw new Usage(`명령: ${Object.keys(COMMANDS).join(" | ")}`);
+  return run(parseArgs(rest));
+}
+
+// Compared as real paths: Node resolves links in import.meta.url but not in argv[1], so a linked path would
+// otherwise do nothing and exit 0.
+const real = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return null;
+  }
+};
+if (process.argv[1] && real(process.argv[1]) !== null && real(process.argv[1]) === real(fileURLToPath(import.meta.url))) {
+  main(process.argv.slice(2)).then(
+    (code) => {
+      process.exitCode = code;
+    },
+    (e) => {
+      process.stderr.write(`${e instanceof Usage ? "" : "내부 오류: "}${e.message}\n`);
+      process.exitCode = 2;
+    },
+  );
+}

package/skills/video-gen/vendor/README.md

@@ -0,0 +1,25 @@
+# vendor
+
+video-gen 이 설치와 내려받기 없이 영상을 만들려고 넣은 파일이다. 모두 고치지 않은 원본이다.
+
+| 파일 | 원본 | 판 | 라이선스 | sha256 |
+|---|---|---|---|---|
+| `canvaskit/canvaskit.js`, `canvaskit/canvaskit.wasm` | npm `canvaskit-wasm` 의 `bin/full/` (Skia) | 0.42.0 | BSD-3-Clause, `canvaskit/LICENSE.md`. 안에 든 ICU, FreeType, HarfBuzz, libjpeg-turbo, libpng, libwebp, zlib, Wuffs 의 고지는 `canvaskit/THIRD-PARTY-NOTICES.md` | js `894815b2d39b24de2eacdb01453778d83e0b6c418b034e3b728e80956ac2a9d5`, wasm `aca7fa6019f95d3de98d4a49ae60a3d66a09e9d5ca74091fbc369b9be959f959` |
+| `h264-mp4-encoder/h264-mp4-encoder.node.js` | npm `h264-mp4-encoder` 의 `embuild/dist/` | 1.0.12 | MIT, `h264-mp4-encoder/LICENSE.md`. 안의 구성요소는 아래 | `f8df9c1791b249f75e5cef77f8e32a135b4cdb2c918a0c4593669e8571085c0c` |
+| `fonts/NotoSans-Regular.ttf`, `fonts/NotoSans-Bold.ttf` | notofonts.github.io `fonts/NotoSans/hinted/ttf/` | | SIL OFL 1.1, `fonts/OFL-noto-sans.md` | Regular `478c558ea716033cd60c03438f628dfa75694dcf6b5f6d505a2f05fd2b4f3823`, Bold `1df075a380fc7cb898acf64c1f7b3b4dd780de3caa860178bf929de35817a913` |
+| `fonts/NotoSansKR-Regular.otf`, `fonts/NotoSansKR-Bold.otf` | noto-cjk `Sans/SubsetOTF/KR/` | | SIL OFL 1.1, `fonts/OFL-noto-sans-kr.md` | Regular `69975a0ac8472717870aefeab0a4d52739308d90856b9955313b2ad5e0148d68`, Bold `5a6ceb287ed2fc6cfc6213144ebea68cbd94b20fc9eb873d8486493bf02d9bda` |
+| `aimotion/LICENSE.md` | github.com/kstost/cokacmotion `LICENSE` | c417b16 | MIT. `scripts/vg-fx.mjs` 가 옮겨 쓴 코드의 고지 | |
+
+## h264-mp4-encoder 안의 구성요소
+
+| 구성요소 | 라이선스 | 원본 소스 |
+|---|---|---|
+| minih264 (H.264 인코더) | public domain(CC0) | https://github.com/TrevorSundberg/minih264 커밋 `25f441086ac8f2eef1c883476c095f9397843ac8` (원본 https://github.com/lieff/minih264) |
+| libmp4v2 (MP4 쓰기) | Mozilla Public License 1.1, 전문 `h264-mp4-encoder/MPL-1.1.md` | https://github.com/TrevorSundberg/libmp4v2 커밋 `d49b4466ed76fc23b59e31a5f7f10f34b30ad7c4` (원본 https://github.com/sergiomb2/libmp4v2) |
+
+- 커밋 번호는 h264-mp4-encoder 의 `v1.0.12` 태그가 가리키는 하위 모듈이다.
+- libmp4v2 는 MPL 1.1 이다. 실행 형태(WASM)로 함께 배포하므로 그 소스를 MPL 1.1 로 구할 수 있게 한다:
+  - 위 커밋의 소스 묶음을 이 저장소의 `third_party/libmp4v2-d49b4466.tar.gz` 에 둔다(npm 패키지에는 넣지 않음). sha256 `c63b3dcb1e7f77e8134b9ccd2500cb144b51b90ba5bce0625313f8d23a9f2e1c`.
+  - banker 는 이 구성요소를 고치지 않았다.
+- 이 인코더의 Emscripten 글루는 불러올 때 프로세스의 처리되지 않은 예외와 거부 처리기를 등록한다. `video-gen.mjs` 는 자기 거부를 모두 처리한다.
+- 판을 올릴 때는 파일을 바꾸고 이 표의 sha256 을 고친 뒤 `scripts/video-gen.test.mjs` 를 돌린다(시험이 sha256 을 대조함).

package/skills/video-gen/vendor/aimotion/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kstost
+
+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/skills/video-gen/vendor/canvaskit/LICENSE.md

@@ -0,0 +1,29 @@
+// Copyright (c) 2011 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------