@kaydash9999/banker-plugins 0.26.1 → 0.28.0

package/skills/wide-pptx/scripts/wide-pptx.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * wide-pptx.mjs: the helper the wide-pptx skill runs. It turns a deck (JSON) into a 16:9 presentation as PPTX and/or
+ * one self-contained HTML file. Pure Node plus the bundled PptxGenJS (vendor/); no install, no network.
+ *
+ *   node wide-pptx.mjs example                                 print a sample deck (JSON)
+ *   node wide-pptx.mjs check --deck <deck.json>
+ *   node wide-pptx.mjs build --deck <deck.json> --out <file.pptx|file.html>... [--force]
+ *
+ * - Image paths in the deck are local files, relative to the deck file's folder; both outputs embed them.
+ * - check and build print warnings for text that may overflow its fixed box (the deck is still built).
+ * - build checks every --out first (kind, duplicates, folder, existing files) and makes every output before it
+ *   writes any, each through a random temporary
+ *   name: a hard link (or an exclusive copy) puts it in place, so a file that appears meanwhile is never replaced;
+ *   --force renames over an existing file instead.
+ *
+ * Exit status: 0 done, 1 the deck has errors, 2 usage error or a file that could not be read or written.
+ */
+import { randomBytes } from "node:crypto";
+import { constants, copyFileSync, existsSync, linkSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, realpathSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { toHtml } from "./wp-html.mjs";
+import { deckBase, readDeck } from "./wp-model.mjs";
+import { toPptx } from "./wp-pptx.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;
+  }
+};
+
+/** Reads --name value pairs; flags listed in bools take no value; --out may repeat. */
+export function parseArgs(argv, bools = ["force"]) {
+  const out = { _: [], 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} 에 값이 없음`);
+    if (name === "out") out.out.push(v);
+    else out[name] = v;
+  }
+  return out;
+}
+
+function readDeckFile(args) {
+  if (!args.deck) throw new Usage("--deck <deck.json> 이 필요함");
+  let deck;
+  try {
+    deck = JSON.parse(readFileSync(args.deck, "utf8").replace(/^\uFEFF/, ""));
+  } catch (e) {
+    throw new Usage(`deck 을 읽지 못함: ${e.message}`);
+  }
+  return readDeck(deck, deckBase(args.deck));
+}
+
+function report(res) {
+  for (const w of res.warnings) process.stderr.write(`경고: ${w}\n`);
+  for (const e of res.errors) process.stderr.write(`오류: ${e}\n`);
+}
+
+function summary(m) {
+  const count = (t) => m.slides.filter((s) => s.type === t).length;
+  const notes = m.slides.filter((s) => s.notes).length;
+  return `슬라이드 ${m.slides.length}, 표 ${count("table")}, 차트 ${count("chart")}, 이미지 ${count("image")}, 노트 ${notes}`;
+}
+
+function cmdCheck(args) {
+  const res = readDeckFile(args);
+  report(res);
+  if (!res.model) return 1;
+  process.stdout.write(`OK ${summary(res.model)}\n`);
+  return 0;
+}
+
+/** An exclusive copy; a copy that fails after making target (disk full) removes what it made. */
+function copyExclusive(tmp, target) {
+  try {
+    copyFileSync(tmp, target, constants.COPYFILE_EXCL);
+  } catch (e) {
+    if (e.code !== "EEXIST") rmSync(target, { force: true });
+    throw e;
+  }
+}
+
+/** Puts tmp at target without replacing a file that appeared meanwhile (link, else an exclusive copy). */
+function placeNew(tmp, target) {
+  try {
+    linkSync(tmp, target);
+  } catch (e) {
+    if (e.code === "EEXIST") throw e;
+    copyExclusive(tmp, target);
+  }
+  rmSync(tmp, { force: true });
+}
+
+function writeOut(target, data, force) {
+  const tmp = join(dirname(target), `.${randomBytes(6).toString("hex")}.wide-pptx.tmp`);
+  try {
+    writeFileSync(tmp, data, { flag: "wx" });
+    if (force) renameSync(tmp, target);
+    else placeNew(tmp, target);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    const why = e.code === "EEXIST" ? "이미 있음(덮어쓰려면 --force)" : e.message;
+    throw new Usage(`쓰지 못함 ${target}: ${why}`);
+  }
+  return target;
+}
+
+/** Checks every output before any is written: kind, duplicates, and (without --force) files already there. */
+function targetsOf(args) {
+  if (!args.out.length) throw new Usage("--out <파일.pptx|파일.html> 이 필요함");
+  const targets = args.out.map((f) => ({ path: resolve(f), kind: extname(f).toLowerCase() }));
+  const bad = targets.filter((x) => ![".pptx", ".html", ".htm"].includes(x.kind));
+  if (bad.length) throw new Usage(`--out 은 .pptx 나 .html 이어야 함: ${bad.map((x) => x.path).join(", ")}`);
+  if (new Set(targets.map((x) => x.path)).size !== targets.length) throw new Usage("--out 에 같은 파일이 두 번 있음");
+  const noDir = targets.filter((x) => !isDir(dirname(x.path)));
+  if (noDir.length) throw new Usage(`출력 폴더가 없음: ${noDir.map((x) => dirname(x.path)).join(", ")}`);
+  const there = targets.filter((x) => existsSync(x.path));
+  if (there.length && !args.force) throw new Usage(`이미 있음(덮어쓰려면 --force): ${there.map((x) => x.path).join(", ")}`);
+  return targets;
+}
+
+async function cmdBuild(args) {
+  const targets = targetsOf(args);
+  const res = readDeckFile(args);
+  report(res);
+  if (!res.model) return 1;
+  // Every output is made before any is written, so a drawing error leaves no half set behind.
+  const made = [];
+  for (const x of targets) made.push({ ...x, data: x.kind === ".pptx" ? await toPptx(res.model) : toHtml(res.model) });
+  for (const x of made) process.stdout.write(`WROTE ${writeOut(x.path, x.data, args.force)}\n`);
+  process.stdout.write(`OK ${summary(res.model)}\n`);
+  return 0;
+}
+
+export async function main(argv) {
+  const [cmd, ...rest] = argv;
+  const args = parseArgs(rest);
+  if (cmd === "example") {
+    process.stdout.write(readFileSync(EXAMPLE, "utf8"));
+    return 0;
+  }
+  if (cmd === "check") return cmdCheck(args);
+  if (cmd === "build") return cmdBuild(args);
+  throw new Usage("명령: example | check | build");
+}
+
+// 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/wide-pptx/scripts/wp-html.mjs

@@ -0,0 +1,98 @@
+// wp-html.mjs: draws the wide-pptx model as one self-contained HTML deck: 1280 x 720 slides (13.333 x 7.5 in at
+// 96 px/in, the PPTX size), scaled to the window, one slide per page when printed. A small inline script moves
+// between slides (arrows, space, PageUp/PageDown, Home/End, click) and N shows the speaker notes. No library, no
+// network: images are data URIs, charts inline SVG. Fonts: "Noto Sans" then "Noto Sans KR" (Hangul falls to KR).
+import { chartSvg, esc } from "./wp-svg.mjs";
+
+const br = (s) => esc(s).replace(/\n/g, "<br>");
+
+const css = (t) => `
+*{box-sizing:border-box;margin:0;padding:0}
+html,body{height:100%;background:#2C3E50;font-family:"Noto Sans","Noto Sans KR",sans-serif;color:#${t.dark}}
+.stage{position:fixed;inset:0;display:flex;align-items:center;justify-content:center;overflow:hidden}
+.slide{position:absolute;width:1280px;height:720px;background:#fff;display:none;transform-origin:center center;overflow:hidden}
+.slide.on{display:block}
+.slide h2{position:absolute;left:58px;top:34px;width:1164px;height:82px;font-size:37px;font-weight:700;display:flex;align-items:center;color:#${t.dark}}
+.bar{position:absolute;left:58px;top:117px;width:106px;height:6px;background:#${t.accent}}
+.foot{position:absolute;left:58px;right:58px;top:672px;height:29px;font-size:13px;color:#${t.muted};display:flex;justify-content:space-between}
+.body{position:absolute;left:77px;top:149px;width:1126px;height:494px}
+ul.b{list-style:none;font-size:27px;line-height:1.35}
+ul.b li{position:relative;padding-left:30px;margin-bottom:11px}
+ul.b li::before{content:"";position:absolute;left:4px;top:.55em;width:10px;height:10px;border-radius:50%;background:#${t.accent}}
+ul.b li.l2{font-size:23px;margin-left:34px}
+ul.b li.l2::before{width:8px;height:8px;border-radius:0;background:#${t.muted}}
+.cols{display:flex;gap:38px;height:100%}.cols>div{flex:1;min-width:0}
+.cols h3{font-size:27px;color:#${t.accent};margin-bottom:18px}
+table.t{width:100%;border-collapse:collapse;font-size:19px}
+table.t th{background:#${t.primary};color:#fff;font-weight:700}
+table.t th,table.t td{border:1px solid #D5D8DC;padding:8px 10px;text-align:left}
+table.t tbody tr:nth-child(odd) td{background:#${t.light}}
+.cap{position:absolute;left:77px;top:605px;width:1126px;font-size:16px;color:#${t.muted}}
+.media{display:flex;align-items:center;justify-content:center;height:446px}
+.media img{max-width:100%;max-height:100%}
+.s-title,.s-closing{background:#${t.primary};color:#fff}
+.s-title .acc{position:absolute;left:77px;top:216px;width:115px;height:8px;background:#${t.accent}}
+.s-title h1{position:absolute;left:77px;top:235px;width:1126px;font-size:53px;font-weight:700;line-height:1.2}
+.s-title .sub{position:absolute;left:77px;top:379px;width:1126px;font-size:29px;color:#D6EAF8}
+.s-title .by{position:absolute;left:77px;top:547px;font-size:21px}
+.s-closing h1{position:absolute;left:77px;top:259px;width:1126px;text-align:center;font-size:53px;font-weight:700}
+.s-closing .sub{position:absolute;left:77px;top:394px;width:1126px;text-align:center;font-size:27px;color:#D6EAF8}
+.s-section,.s-quote{background:#${t.light}}
+.s-section .edge{position:absolute;left:0;top:0;width:34px;height:720px;background:#${t.accent}}
+.s-section h1{position:absolute;left:96px;top:259px;width:1088px;font-size:48px;font-weight:700}
+.s-section .sub{position:absolute;left:96px;top:374px;width:1088px;font-size:27px;color:#${t.muted}}
+.s-quote .q{position:absolute;left:115px;top:192px;width:1050px;height:269px;display:flex;align-items:center;justify-content:center;text-align:center;font-size:40px;font-style:italic}
+.s-quote .who{position:absolute;left:115px;top:470px;width:1050px;text-align:right;font-size:24px;color:#${t.muted}}
+.s-quote .qt{position:absolute;left:58px;top:34px;font-size:24px;font-weight:700;color:#${t.accent}}
+.notes{position:fixed;left:0;right:0;bottom:0;max-height:35%;overflow:auto;background:#fff;border-top:4px solid #${t.accent};padding:14px 22px;font-size:18px;display:none;white-space:pre-wrap}
+body.show-notes .notes{display:block}
+.hint{position:fixed;right:12px;bottom:8px;color:#BDC3C7;font-size:12px}
+@page{size:13.333in 7.5in;margin:0}
+@media print{html,body{background:#fff;height:auto}.stage{position:static;display:block}.slide{position:relative;display:block;transform:none!important;page-break-after:always;break-after:page}
+.notes,.hint{display:none!important}*{-webkit-print-color-adjust:exact;print-color-adjust:exact}}
+`;
+
+const bullets = (list) => (list.length ? `<ul class="b">${list.map((b) => `<li class="l${b.level}">${br(b.text)}</li>`).join("")}</ul>` : "");
+const head = (s) => `<h2>${br(s.title)}</h2><div class="bar"></div>`;
+const cap = (s) => (s.caption ? `<div class="cap">${br(s.caption)}</div>` : "");
+
+function table(t) {
+  const th = t.header.length ? `<thead><tr>${t.header.map((h) => `<th>${br(h)}</th>`).join("")}</tr></thead>` : "";
+  return `<table class="t">${th}<tbody>${t.rows.map((r) => `<tr>${r.map((c) => `<td>${br(c)}</td>`).join("")}</tr>`).join("")}</tbody></table>`;
+}
+
+const BODY = {
+  title: (s) => `<div class="acc"></div><h1>${br(s.title)}</h1>${s.subtitle ? `<div class="sub">${br(s.subtitle)}</div>` : ""}`
+    + `<div class="by">${esc([s.presenter, s.date].filter(Boolean).join("  |  "))}</div>`,
+  section: (s) => `<div class="edge"></div><h1>${br(s.title)}</h1>${s.subtitle ? `<div class="sub">${br(s.subtitle)}</div>` : ""}`,
+  bullets: (s) => `${head(s)}<div class="body">${bullets(s.bullets)}</div>`,
+  two: (s) => `${head(s)}<div class="body cols">${[s.left, s.right].map((c) => `<div>${c.heading ? `<h3>${br(c.heading)}</h3>` : ""}${bullets(c.bullets)}</div>`).join("")}</div>`,
+  table: (s) => `${head(s)}<div class="body">${table(s.table)}</div>${cap(s)}`,
+  chart: (s) => `${head(s)}<div class="body media">${chartSvg(s.chart, 1126, 446)}</div>${cap(s)}`,
+  image: (s) => `${head(s)}<div class="body media"><img alt="${esc(s.caption || s.title)}" src="data:${s.image.mime};base64,${s.image.data.toString("base64")}"></div>${cap(s)}`,
+  quote: (s) => `${s.title ? `<div class="qt">${br(s.title)}</div>` : ""}<div class="q">“${br(s.quote)}”</div>${s.by ? `<div class="who">- ${br(s.by)}</div>` : ""}`,
+  closing: (s) => `<h1>${br(s.title)}</h1>${s.subtitle ? `<div class="sub">${br(s.subtitle)}</div>` : ""}`,
+};
+
+function slideHtml(s, i, m) {
+  const plain = s.type === "title" || s.type === "closing";
+  const foot = plain ? "" : `<div class="foot"><span>${esc(m.footer)}</span><span>${i + 1}</span></div>`;
+  return `<section class="slide s-${s.type}" data-notes="${esc(s.notes)}">${BODY[s.type](s)}${foot}</section>`;
+}
+
+// The deck's own script: scale to the window, move between slides, show notes. Reads nothing from outside.
+const SCRIPT = `(function(){var s=[].slice.call(document.querySelectorAll('.slide')),n=document.querySelector('.notes'),i=0;
+function fit(){var k=Math.min(innerWidth/1280,innerHeight/720);s.forEach(function(e){e.style.transform='scale('+k+')';});}
+function go(j){i=Math.max(0,Math.min(s.length-1,j));s.forEach(function(e,x){e.classList.toggle('on',x===i);});n.textContent=s[i].getAttribute('data-notes')||'(노트 없음)';history.replaceState(null,'','#'+(i+1));}
+addEventListener('keydown',function(e){var k=e.key;if(k==='ArrowRight'||k==='PageDown'||k===' ')go(i+1);else if(k==='ArrowLeft'||k==='PageUp')go(i-1);else if(k==='Home')go(0);else if(k==='End')go(s.length-1);else if(k==='n'||k==='N')document.body.classList.toggle('show-notes');else return;e.preventDefault();});
+document.querySelector('.stage').addEventListener('click',function(e){go(e.clientX<innerWidth/3?i-1:i+1);});
+addEventListener('resize',fit);fit();go((parseInt(location.hash.slice(1),10)||1)-1);})();`;
+
+/** Returns the HTML text for a model. */
+export function toHtml(m) {
+  const slides = m.slides.map((s, i) => slideHtml(s, i, m)).join("\n");
+  return `<!doctype html>\n<html lang="ko"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">`
+    + `<title>${esc(m.title)}</title><style>${css(m.theme)}</style></head><body>`
+    + `<div class="stage">\n${slides}\n</div><div class="notes"></div><div class="hint">← → 넘김, N 노트</div>`
+    + `<script>${SCRIPT}</script></body></html>\n`;
+}

package/skills/wide-pptx/scripts/wp-model.mjs

@@ -0,0 +1,236 @@
+// wp-model.mjs: reads a wide-pptx deck (JSON), checks it and returns one model that the PPTX and HTML writers both
+// draw. Images are read here (local regular files only) so both outputs embed the same bytes. No network.
+import { readFileSync, statSync } from "node:fs";
+import { dirname, isAbsolute, resolve, win32 } from "node:path";
+
+export const TYPES = ["title", "section", "bullets", "two", "table", "chart", "image", "quote", "closing"];
+export const CHARTS = ["bar", "line", "pie"];
+const HEX = /^#?[0-9A-Fa-f]{6}$/;
+export const THEME = { primary: "1F3864", accent: "2E86C1", dark: "1B2631", light: "F4F6F7", muted: "5D6D7E" };
+export const PALETTE = ["2E86C1", "E67E22", "27AE60", "9B59B6", "E74C3C", "16A085", "F1C40F", "34495E"];
+const MAX_IMAGE = 20 * 1024 * 1024;
+// Soft limits: past these the fixed boxes overflow or crowd, so check warns (the deck is still built).
+export const LIMITS = { tableRows: 12, tableCols: 7, chartPoints: 24, piePoints: 12 };
+
+const arr = (v) => (Array.isArray(v) ? v : []);
+const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
+export const hex = (c) => String(c).replace(/^#/, "").toUpperCase();
+
+// XML 1.0 has no place for most control characters. PowerPoint's soft line break comes out of copied text as
+// U+000B, so that one becomes a line break; the rest, U+FFFE/U+FFFF and lone surrogates are dropped.
+const LINE_TAB = /\u{B}/gu;
+const NOT_XML = /[\u{0}-\u{8}\u{C}\u{E}-\u{1F}\u{FFFE}\u{FFFF}]/gu;
+// In a /u pattern a well-formed pair is one code point, so this class matches lone surrogates only.
+const LONE = /[\u{D800}-\u{DFFF}]/gu;
+export const cleanText = (s) => s.replace(LINE_TAB, "\n").replace(NOT_XML, "").replace(LONE, "");
+
+/** A text field: a string (cleaned) or a finite number; absent is empty; anything else is an error. */
+function text(v, what, ctx) {
+  if (v === undefined || v === null) return "";
+  if (typeof v === "string") return cleanText(v);
+  if (typeof v === "number" && Number.isFinite(v)) return String(v);
+  ctx.errors.push(`${what}: 글이어야 함`);
+  return "";
+}
+
+/** A list field: absent is empty; present but not an array is an error. */
+function list(v, what, ctx) {
+  if (v === undefined || v === null) return [];
+  if (Array.isArray(v)) return v;
+  ctx.errors.push(`${what}: 배열이어야 함`);
+  return [];
+}
+
+// Width in em of a line: Hangul, CJK and full-width forms take a full em, other characters about half.
+const WIDE = /[\u{1100}-\u{11FF}\u{2E80}-\u{9FFF}\u{AC00}-\u{D7A3}\u{F900}-\u{FAFF}\u{FF00}-\u{FFEF}]/u;
+export const ems = (s) => Array.from(s).reduce((n, ch) => n + (WIDE.test(ch) ? 1 : 0.55), 0);
+const linesOf = (s, pt, widthIn) => s.split("\n").reduce((n, l) => n + Math.max(1, Math.ceil((ems(l) * pt) / 72 / widthIn)), 0);
+
+/** Estimated height in inches of bullets set at 20 pt (level 2 at 17 pt) in a box widthIn wide. */
+export function bulletsHeight(bullets, widthIn) {
+  return bullets.reduce((h, b) => {
+    const pt = b.level === 2 ? 17 : 20;
+    return h + (linesOf(b.text, pt, widthIn - (b.level === 2 ? 0.6 : 0.35)) * pt * 1.2) / 72 + 8 / 72;
+  }, 0);
+}
+
+function themeOf(deck, ctx) {
+  const t = { ...THEME };
+  for (const [k, v] of Object.entries(obj(deck.theme))) {
+    if (!Object.prototype.hasOwnProperty.call(THEME, k)) ctx.errors.push(`theme.${k} 는 없는 칸(${Object.keys(THEME).join(", ")})`);
+    else if (!HEX.test(String(v))) ctx.errors.push(`theme.${k} 색이 6자리 16진수가 아님: ${String(v)}`);
+    else t[k] = hex(v);
+  }
+  return t;
+}
+
+/** Bullets: strings, or { text, level } with level 1 or 2. box: { w, h } in inches for the overflow estimate. */
+function bulletsOf(raw, what, ctx, box) {
+  const out = list(raw, what, ctx).map((b, i) => {
+    if (b === null || b === undefined) ctx.errors.push(`${what}[${i}]: 글이어야 함`);
+    if (b && typeof b === "object" && !Array.isArray(b)) return { text: text(b.text, `${what}[${i}].text`, ctx), level: Number(b.level) === 2 ? 2 : 1 };
+    return { text: text(b, `${what}[${i}]`, ctx), level: 1 };
+  });
+  if (bulletsHeight(out, box.w) > box.h) ctx.warnings.push(`${what}: 글머리가 상자 높이를 넘을 수 있음(나누거나 줄이기를 권함)`);
+  return out;
+}
+
+function tableOf(s, what, ctx) {
+  const header = list(s.header, `${what}.header`, ctx).map((h, i) => text(h, `${what}.header[${i}]`, ctx));
+  const rows = list(s.rows, `${what}.rows`, ctx).map((r, i) => list(r, `${what}.rows[${i}]`, ctx).map((c, j) => text(c, `${what}.rows[${i}][${j}]`, ctx)));
+  const width = rows.reduce((m, r) => Math.max(m, r.length), header.length);
+  if (!width) ctx.errors.push(`${what}: 표에 칸이 없음`);
+  if (rows.length > LIMITS.tableRows) ctx.warnings.push(`${what}: 표 행이 ${LIMITS.tableRows}개를 넘음`);
+  if (width > LIMITS.tableCols) ctx.warnings.push(`${what}: 표 열이 ${LIMITS.tableCols}개를 넘음`);
+  const pad = (r) => [...r, ...Array(Math.max(0, width - r.length)).fill("")];
+  return { header: header.length ? pad(header) : [], rows: rows.map(pad) };
+}
+
+function seriesOf(raw, what, ctx) {
+  return list(raw, `${what}.series`, ctx).map(obj).map((x, k) => {
+    const values = list(x.values, `${what}.series[${k}].values`, ctx);
+    if (values.some((v) => typeof v !== "number" || !Number.isFinite(v))) ctx.errors.push(`${what}: 계열 값은 숫자만(null 이나 글자 안 됨)`);
+    return { name: text(x.name, `${what}.series[${k}].name`, ctx), values: values.map((v) => (typeof v === "number" ? v : 0)) };
+  });
+}
+
+function chartOf(s, what, ctx) {
+  const c = obj(s.chart);
+  const kind = text(c.kind || "bar", `${what}.chart.kind`, ctx);
+  if (!CHARTS.includes(kind)) ctx.errors.push(`${what}: chart.kind 는 ${CHARTS.join(", ")} 중 하나`);
+  const labels = list(c.labels, `${what}.chart.labels`, ctx).map((l, i) => text(l, `${what}.chart.labels[${i}]`, ctx));
+  const series = seriesOf(c.series, `${what}.chart`, ctx);
+  checkSeries(kind, labels, series, what, ctx);
+  return { kind, labels, series, unit: text(c.unit, `${what}.chart.unit`, ctx) };
+}
+
+function checkSeries(kind, labels, series, what, ctx) {
+  if (!labels.length || !series.length) ctx.errors.push(`${what}: chart.labels 와 chart.series 가 필요함`);
+  if (series.some((x) => x.values.length !== labels.length)) ctx.errors.push(`${what}: 계열마다 값 수가 labels 수와 같아야 함`);
+  const names = series.map((x) => x.name.trim());
+  if (series.length > 1 && (names.some((n) => !n) || new Set(names).size !== names.length)) ctx.errors.push(`${what}: 계열이 둘 이상이면 이름이 비지 않고 서로 달라야 함`);
+  if (kind === "pie") checkPie(series, labels, what, ctx);
+  else if (labels.length > LIMITS.chartPoints) ctx.warnings.push(`${what}: 차트 항목이 ${LIMITS.chartPoints}개를 넘음`);
+}
+
+function checkPie(series, labels, what, ctx) {
+  const v = series[0]?.values ?? [];
+  if (series.length !== 1 || v.some((x) => x < 0)) ctx.errors.push(`${what}: pie 는 음수 없는 계열 하나`);
+  else if (!v.some((x) => x > 0)) ctx.errors.push(`${what}: pie 값이 모두 0`);
+  if (labels.length > LIMITS.piePoints) ctx.warnings.push(`${what}: pie 항목이 ${LIMITS.piePoints}개를 넘음(범례가 잘림)`);
+}
+
+const IMAGE_TYPES = [
+  { mime: "image/png", magic: [0x89, 0x50, 0x4e, 0x47] },
+  { mime: "image/jpeg", magic: [0xff, 0xd8, 0xff] },
+  { mime: "image/gif", magic: [0x47, 0x49, 0x46, 0x38] },
+];
+
+const isPath = (p) => isAbsolute(p) || win32.isAbsolute(p) || !/^[a-z][a-z0-9+.-]+:/i.test(p);
+
+/** Reads a local PNG, JPEG or GIF once; the type comes from its first bytes, not its name. */
+function imageOf(s, what, ctx) {
+  const p = text(s.image, `${what}.image`, ctx);
+  if (!p || !isPath(p)) {
+    ctx.errors.push(`${what}: image 는 로컬 파일 경로여야 함(URL 은 받지 않음)`);
+    return null;
+  }
+  const file = isAbsolute(p) || win32.isAbsolute(p) ? p : resolve(ctx.base, p);
+  try {
+    const st = statSync(file);
+    if (!st.isFile()) throw new Error("보통 파일이 아님");
+    if (st.size > MAX_IMAGE) throw new Error("20MB 를 넘음");
+    const data = readFileSync(file);
+    const t = IMAGE_TYPES.find((x) => x.magic.every((b, i) => data[i] === b));
+    if (!t) throw new Error("PNG, JPEG, GIF 가 아님");
+    const size = imageSize(data, t.mime);
+    if (!size) ctx.warnings.push(`${what}: 그림 크기를 읽지 못해 상자 비율로 맞춤`);
+    return { file, mime: t.mime, size, data };
+  } catch (e) {
+    ctx.errors.push(`${what}: 이미지를 읽지 못함 (${file}: ${e.message})`);
+    return null;
+  }
+}
+
+/** Pixel size from the header (PNG IHDR, GIF screen, JPEG SOFn), or null. */
+export function imageSize(b, mime) {
+  if (mime === "image/png" && b.length > 24) return { w: b.readUInt32BE(16), h: b.readUInt32BE(20) };
+  if (mime === "image/gif" && b.length > 10) return { w: b.readUInt16LE(6), h: b.readUInt16LE(8) };
+  return mime === "image/jpeg" ? jpegSize(b) : null;
+}
+
+/** Walks the JPEG segments to the first start-of-frame marker (SOF0..SOF15 but DHT, JPG, DAC); fill bytes skipped. */
+function jpegSize(b) {
+  for (let i = 2; i + 9 < b.length;) {
+    if (b[i] !== 0xff) return null;
+    if (b[i + 1] === 0xff) {
+      i++;
+      continue;
+    }
+    const marker = b[i + 1];
+    if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker)) return { w: b.readUInt16BE(i + 7), h: b.readUInt16BE(i + 5) };
+    const len = b.readUInt16BE(i + 2);
+    if (len < 2) return null;
+    i += 2 + len;
+  }
+  return null;
+}
+
+const BOX = { w: 11.73, h: 5.15 };
+const HALF = { w: 5.66, h: 4.55 };
+
+const FIELDS = {
+  title: (s, w, ctx) => ({ subtitle: text(s.subtitle, `${w}.subtitle`, ctx), presenter: text(s.presenter, `${w}.presenter`, ctx), date: text(s.date, `${w}.date`, ctx) }),
+  section: (s, w, ctx) => ({ subtitle: text(s.subtitle, `${w}.subtitle`, ctx) }),
+  bullets: (s, w, ctx) => ({ bullets: bulletsOf(s.bullets, `${w}.bullets`, ctx, BOX) }),
+  two: (s, w, ctx) => ({ left: columnOf(s.left, `${w}.left`, ctx), right: columnOf(s.right, `${w}.right`, ctx) }),
+  table: (s, w, ctx) => ({ table: tableOf(s, w, ctx), caption: text(s.caption, `${w}.caption`, ctx) }),
+  chart: (s, w, ctx) => ({ chart: chartOf(s, w, ctx), caption: text(s.caption, `${w}.caption`, ctx) }),
+  image: (s, w, ctx) => ({ image: imageOf(s, w, ctx), caption: text(s.caption, `${w}.caption`, ctx) }),
+  quote: (s, w, ctx) => ({ quote: text(s.quote, `${w}.quote`, ctx), by: text(s.by, `${w}.by`, ctx) }),
+  closing: (s, w, ctx) => ({ subtitle: text(s.subtitle, `${w}.subtitle`, ctx) }),
+};
+
+function columnOf(raw, what, ctx) {
+  const c = obj(raw);
+  const heading = text(c.heading, `${what}.heading`, ctx);
+  return { heading, bullets: bulletsOf(c.bullets, `${what}.bullets`, ctx, heading ? HALF : { ...HALF, h: HALF.h + 0.6 }) };
+}
+
+function slideOf(raw, i, ctx) {
+  const s = obj(raw);
+  const what = `slides[${i}]`;
+  const type = typeof s.type === "string" ? s.type : "";
+  if (!TYPES.includes(type)) {
+    ctx.errors.push(`${what}: type 은 ${TYPES.join(", ")} 중 하나 (${String(s.type)})`);
+    return null;
+  }
+  const title = text(s.title, `${what}.title`, ctx);
+  if (type !== "quote" && !title.trim()) ctx.errors.push(`${what}: title 이 없음`);
+  if ((ems(title) * 28) / 72 > 12.1 && !["title", "closing"].includes(type)) ctx.warnings.push(`${what}: 제목이 한 줄을 넘을 수 있음`);
+  return { type, title, notes: text(s.notes, `${what}.notes`, ctx), ...FIELDS[type](s, what, ctx) };
+}
+
+/**
+ * Checks a deck and returns { errors, warnings, model }; model is null when there are errors. base is the folder
+ * relative image paths start from (the deck file's folder).
+ */
+export function readDeck(deck, base) {
+  const errors = [];
+  const warnings = [];
+  if (!deck || typeof deck !== "object" || Array.isArray(deck)) return { errors: ["deck 은 JSON 객체여야 함"], warnings, model: null };
+  const ctx = { errors, warnings, base: base || process.cwd() };
+  const title = text(deck.title, "title", ctx);
+  if (!title.trim()) errors.push("title 이 없음");
+  if (!Array.isArray(deck.slides) || !deck.slides.length) errors.push("slides 가 비어 있음");
+  const model = {
+    title,
+    author: text(deck.author, "author", ctx),
+    footer: text(deck.footer, "footer", ctx),
+    theme: themeOf(deck, ctx),
+    slides: arr(deck.slides).map((s, i) => slideOf(s, i, ctx)).filter(Boolean),
+  };
+  return { errors, warnings, model: errors.length ? null : model };
+}
+
+export const deckBase = (file) => dirname(resolve(file));