@kaydash9999/banker-plugins 0.27.0 → 0.28.0

package/skills/wbs-gen/scripts/wg-html.mjs

@@ -0,0 +1,108 @@
+// wg-html.mjs: draws the wbs-gen model as one self-contained HTML file (a table and CSS, no script, no library, no
+// network). The grid matches the XLSX: 8 fixed columns, week and day headers, cell-fill bars, ◆, the red gate line.
+// Colours reach the page only as 6-digit hex checked by wg-plan.mjs. Fonts: Noto Sans first and Noto Sans KR next;
+// Noto Sans has no Hangul, so Hangul is drawn in Noto Sans KR and everything else in Noto Sans. Nothing is embedded:
+// a viewer without the fonts uses its own sans-serif.
+
+const esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const br = (s) => esc(s).replace(/\n/g, "<br>");
+const WIDTHS = [48, 260, 84, 70, 210, 56, 56, 60];
+const DAY = 36;
+const ALIGN = ["c", "l", "c", "c", "l", "c", "c", "c"];
+
+const CSS = `
+*{box-sizing:border-box}
+body{margin:16px;font-family:"Noto Sans","Noto Sans KR",sans-serif;color:#2C3E50;font-size:12px}
+.wrap{overflow:auto;max-height:calc(100vh - 32px);border:1px solid #D5D8DC}
+table{border-collapse:separate;border-spacing:0;table-layout:fixed}
+th,td{border-right:1px solid #D5D8DC;border-bottom:1px solid #D5D8DC;padding:2px 4px;overflow:hidden;vertical-align:middle;height:22px}
+.l{text-align:left;white-space:normal;word-break:keep-all}.c,th{text-align:center}
+.title th{background:#1F3864;color:#fff;font-size:15px;text-align:left;height:34px;padding:0 10px}
+.h th{background:#34495E;color:#fff;font-size:12px}
+.h th.w{background:#5D6D7E}
+.d th{background:#EBEDEF;color:#2C3E50;font-size:10px;line-height:1.2;height:36px;padding:0;letter-spacing:-.3px}
+thead tr th{position:sticky;z-index:2}
+.title th{top:0}.h th{top:34px}.d th{top:56px}
+.fix{position:sticky;z-index:1;background:#fff}
+thead .fix{z-index:3}
+tr.group td{font-weight:700;color:#1B2631}
+.dia{color:#C0392B;font-weight:700;text-align:center;padding:0}
+.dot{outline:1px dotted #7F8C8D;outline-offset:-2px}
+.gate{box-shadow:inset 2px 0 0 #C0392B}
+.notes{margin-top:18px;font-size:12px}
+.notes h3{font-size:13px;margin:14px 0 6px;color:#1B2631}
+.notes ul{margin:0;padding:0;list-style:none}
+.notes li{margin:3px 0;display:flex;align-items:center;gap:8px}
+.sw{display:inline-block;width:28px;height:14px;border:1px solid #D5D8DC}
+.sw.dotted{border:1px dotted #7F8C8D}
+.sw.gateline{border:0;border-left:2px solid #C0392B;border-right:2px solid #C0392B;width:10px}
+.sw.diamond{border:0;color:#C0392B;font-weight:700;text-align:center;line-height:14px}
+@page{size:A3 landscape;margin:10mm}
+@media print{body{margin:0}.wrap{overflow:visible;max-height:none;border:0}thead tr th,.fix{position:static}
+*{-webkit-print-color-adjust:exact;print-color-adjust:exact}}
+`;
+
+function colgroup(n) {
+  return `<colgroup>${WIDTHS.map((w) => `<col style="width:${w}px">`).join("")}${`<col style="width:${DAY}px">`.repeat(n)}</colgroup>`;
+}
+
+// Left offsets of the 8 sticky columns.
+const LEFT = WIDTHS.map((_, i) => WIDTHS.slice(0, i).reduce((a, b) => a + b, 0));
+const fixStyle = (c, bg) => ` class="fix" style="left:${LEFT[c]}px${bg ? `;background:#${bg}` : ""}"`;
+
+function head(m, gate) {
+  const total = 8 + m.days.length;
+  const title = `<tr class="title"><th colspan="${total}">${esc(m.title)}</th></tr>`;
+  const fixed = m.head.map((h, c) => `<th rowspan="2" class="fix" style="left:${LEFT[c]}px;background:#34495E">${br(h)}</th>`).join("");
+  const wk = m.weeks.map((w) => `<th class="w${gate.has(w.first) ? " gate" : ""}" colspan="${w.count}">${esc(w.label)}</th>`).join("");
+  const days = m.days.map((d, i) => `<th${gate.has(i) ? ' class="gate"' : ""}>${esc(d.label)}<br>${esc(d.dow)}</th>`).join("");
+  return `<thead>${title}<tr class="h">${fixed}${wk}</tr><tr class="d">${days}</tr></thead>`;
+}
+
+function dayTd(row, i, gate) {
+  const cls = [gate.has(i) ? "gate" : ""];
+  if (row.diamonds.includes(i)) {
+    cls.push("dia", row.dotted ? "dot" : "");
+    const bg = row.fill ? ` style="background:#${row.fill}"` : "";
+    return `<td class="${cls.filter(Boolean).join(" ")}"${bg}>◆</td>`;
+  }
+  const fill = i >= row.from && i <= row.to ? row.bar : row.fill;
+  const c = cls.filter(Boolean).join(" ");
+  return `<td${c ? ` class="${c}"` : ""}${fill ? ` style="background:#${fill}"` : ""}></td>`;
+}
+
+function body(m, gate) {
+  const rows = m.rows.map((row) => {
+    const fixed = row.cells.map((v, c) => `<td${fixStyle(c, row.fill)}><div class="${ALIGN[c]}">${br(v)}</div></td>`)
+      .join("");
+    const days = m.days.map((_, i) => dayTd(row, i, gate)).join("");
+    return `<tr class="${row.kind}">${fixed}${days}</tr>`;
+  });
+  return `<tbody>${rows.join("")}</tbody>`;
+}
+
+function swatch(item) {
+  if (item.type === "diamond") return `<span class="sw diamond">◆</span>`;
+  if (item.type === "gate") return `<span class="sw gateline"></span>`;
+  const cls = item.type === "dotted" ? "sw dotted" : "sw";
+  return `<span class="${cls}" style="background:#${item.color}"></span>`;
+}
+
+function notes(m) {
+  const legend = m.legend.length
+    ? `<h3>[범례]</h3><ul>${m.legend.map((l) => `<li>${swatch(l)}<span>${esc(l.label)}</span></li>`).join("")}</ul>`
+    : "";
+  const blocks = m.notes.map((n) => `${n.heading ? `<h3>${esc(n.heading)}</h3>` : ""}<ul>${n.lines.map((l) => `<li>${esc(l)}</li>`).join("")}</ul>`);
+  return `<section class="notes">${legend}${blocks.join("")}</section>`;
+}
+
+/** Returns the HTML text for a layout model. */
+export function toHtml(m) {
+  const gate = new Set(m.gates.map((g) => g.col));
+  // A fixed width keeps every column at its colgroup width, so the sticky offsets match in a narrow window too.
+  const width = WIDTHS.reduce((x, y) => x + y, 0) + DAY * m.days.length;
+  const table = `<table style="width:${width}px">${colgroup(m.days.length)}${head(m, gate)}${body(m, gate)}</table>`;
+  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.split("    |    ")[0])}</title><style>${CSS}</style></head>`
+    + `<body><div class="wrap">${table}</div>${notes(m)}</body></html>\n`;
+}

package/skills/wbs-gen/scripts/wg-plan.mjs

@@ -0,0 +1,230 @@
+// wg-plan.mjs: reads a wbs-gen plan (JSON), checks it and lays it out as one model that the XLSX and HTML writers
+// both draw. Nothing here touches the network or the disk.
+import { businessDays, daysBetween, dowName, keyMs, mmdd, parseHolidays, resolveDate, weeks } from "./wg-dates.mjs";
+
+export const HEAD = ["WBS", "작업", "담당", "우선순위", "선행·미확정", "시작", "종료", "일수\n(영업일)"];
+export const KINDS = ["group", "task", "constraint", "milestone"];
+// Five years of calendar days at most: about 1300 day columns, well inside Excel's 16384 columns.
+export const MAX_SPAN_DAYS = 5 * 366;
+// Excel keeps at most 32767 characters in a cell.
+export const MAX_TEXT = 32767;
+const HEX = /^#?[0-9A-Fa-f]{6}$/;
+const DEFAULT_BAR = "5D6D7E";
+const DEFAULT_LIGHT = "EBEDEF";
+
+export const hex = (c) => String(c).replace(/^#/, "").toUpperCase();
+const str = (v) => (v === undefined || v === null ? "" : String(v));
+const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : {});
+// Lookups by a plan string go through own keys only, so "constructor" or "__proto__" is just a missing name.
+const own = (o, k) => (Object.prototype.hasOwnProperty.call(o, k) ? o[k] : undefined);
+
+/** A list field: absent is empty; present but not an array is an error. */
+function list(plan, name, errors) {
+  const v = plan[name];
+  if (v === undefined || v === null) return [];
+  if (Array.isArray(v)) return v;
+  errors.push(`${name} 는 배열이어야 함`);
+  return [];
+}
+
+function readRange(plan, errors) {
+  const range = { start: str(plan.start), end: str(plan.end) };
+  if (keyMs(range.start) === null || keyMs(range.end) === null) {
+    errors.push("start, end 는 YYYY-MM-DD 여야 함");
+    return null;
+  }
+  if (range.end < range.start) {
+    errors.push("end 가 start 보다 앞섬");
+    return null;
+  }
+  if (daysBetween(range.start, range.end) > MAX_SPAN_DAYS) {
+    errors.push("기간이 5년을 넘음. 단계나 해로 나누어 만드십시오");
+    return null;
+  }
+  return range;
+}
+
+/** Checks the plan's frame (title, range, holidays, parts, bars). */
+function readFrame(plan, errors, warnings) {
+  if (!str(plan.title).trim()) errors.push("title 이 없음");
+  const range = readRange(plan, errors);
+  if (!range) return null;
+  const h = parseHolidays(plan.holidays ?? [], range);
+  if (h.bad.length) errors.push(`공휴일을 날짜로 읽지 못함: ${h.bad.join(", ")}`);
+  if (h.ambiguous.length) errors.push(`기간 안 두 해에 걸리는 M/D: ${h.ambiguous.join(", ")}. YYYY-MM-DD 로 적으십시오`);
+  if (h.outside.length) warnings.push(`기간 밖 공휴일은 뺌: ${h.outside.join(", ")}`);
+  return { range, holidays: h.keys, parts: readParts(obj(plan.parts), errors), bars: readBars(obj(plan.bars), errors) };
+}
+
+function readBars(given, errors) {
+  const bars = Object.create(null);
+  for (const [k, v] of Object.entries(given)) {
+    if (HEX.test(str(v))) bars[k] = hex(v);
+    else errors.push(`bars.${k} 색이 6자리 16진수가 아님: ${str(v)}`);
+  }
+  return bars;
+}
+
+function readParts(parts, errors) {
+  const out = Object.create(null);
+  for (const [id, raw] of Object.entries(parts)) {
+    const p = obj(raw);
+    for (const k of ["light", "dark"]) {
+      if (p[k] !== undefined && !HEX.test(str(p[k]))) errors.push(`parts.${id}.${k} 색이 6자리 16진수가 아님: ${str(p[k])}`);
+    }
+    out[id] = { name: str(p.name || id), light: hex(p.light ?? DEFAULT_LIGHT), dark: hex(p.dark ?? DEFAULT_BAR), legend: p.legend !== false };
+  }
+  return out;
+}
+
+/** A plan date as a key inside the range that is a working day, or null with an error. */
+function workday(text, what, ctx) {
+  const r = resolveDate(text, ctx.range);
+  if (!r) ctx.errors.push(`${what}: 날짜로 읽지 못함 (${str(text)})`);
+  else if (r.ambiguous) ctx.errors.push(`${what}: ${str(text)} 가 기간 안 두 해에 걸림. YYYY-MM-DD 로 적으십시오`);
+  else if (!r.inRange) ctx.errors.push(`${what}: 기간 밖 (${r.key})`);
+  else if (ctx.index.get(r.key) === undefined) ctx.errors.push(`${what}: 주말이나 공휴일 (${r.key} ${dowName(r.key)})`);
+  else return r.key;
+  return null;
+}
+
+function gatesOf(plan, ctx) {
+  return list(plan, "gates", ctx.errors).map((g, i) => {
+    const key = workday(obj(g).date, `gates[${i}]`, ctx);
+    return key && { key, col: ctx.index.get(key), label: str(obj(g).label) };
+  }).filter(Boolean);
+}
+
+function barColor(row, part, ctx) {
+  if (row.bar !== undefined) {
+    if (HEX.test(str(row.bar))) return hex(row.bar);
+    ctx.errors.push(`${str(row.wbs || row.task)}: bar 색이 6자리 16진수가 아님`);
+  }
+  return own(ctx.bars, str(row.priority)) ?? part?.dark ?? DEFAULT_BAR;
+}
+
+function partOf(row, what, ctx) {
+  if (row.part === undefined) return null;
+  const p = own(ctx.parts, str(row.part));
+  if (!p) ctx.errors.push(`${what}: parts 에 없는 part (${str(row.part)})`);
+  return p ?? null;
+}
+
+/** Start and end of a task or constraint; a constraint may give date alone. */
+function spanOf(row, what, ctx) {
+  const s = workday(row.start ?? row.date, `${what} 시작`, ctx);
+  const e = workday(row.end ?? row.start ?? row.date, `${what} 종료`, ctx);
+  if (s && e && e < s) {
+    ctx.errors.push(`${what}: 종료가 시작보다 앞섬`);
+    return null;
+  }
+  return s && e ? { s, e } : null;
+}
+
+function cellsOf(row, extra) {
+  return [str(row.wbs), str(row.task), str(row.owner), str(row.priority), str(row.pending), ...extra];
+}
+
+function layRow(row, i, ctx) {
+  const kind = str(row.kind || "task");
+  const what = `rows[${i}] ${str(row.wbs || row.task)}`.trim();
+  if (!KINDS.includes(kind)) {
+    ctx.errors.push(`${what}: kind 는 ${KINDS.join(", ")} 중 하나여야 함 (${kind})`);
+    return null;
+  }
+  const part = partOf(row, what, ctx);
+  const out = { kind, fill: null, bar: null, from: -1, to: -1, diamonds: [], dotted: false, cells: cellsOf(row, ["", "", ""]) };
+  if (kind === "group") return { ...out, fill: part?.light ?? DEFAULT_LIGHT };
+  if (kind === "milestone") {
+    const k = workday(row.date ?? row.start, what, ctx);
+    return { ...out, diamonds: k ? [ctx.index.get(k)] : [] };
+  }
+  return laySpan(row, kind, part, what, ctx, out);
+}
+
+function laySpan(row, kind, part, what, ctx, out) {
+  const span = spanOf(row, what, ctx);
+  if (!span) return out;
+  const from = ctx.index.get(span.s);
+  const to = ctx.index.get(span.e);
+  const cells = cellsOf(row, [ctx.label(span.s), ctx.label(span.e), to - from + 1]);
+  if (kind === "constraint") return { ...out, diamonds: [to], dotted: true, cells };
+  return { ...out, bar: barColor(row, part, ctx), from, to, cells };
+}
+
+function legendOf(plan, parts, gates, errors) {
+  const items = Object.values(parts).filter((p) => p.legend).map((p) => ({ type: "swatch", color: p.dark, label: p.name }));
+  list(plan, "legend", errors).map(obj).forEach((l, i) => {
+    if (!HEX.test(str(l.color))) errors.push(`legend[${i}] 색이 6자리 16진수가 아님`);
+    else items.push({ type: l.dotted ? "dotted" : "swatch", color: hex(l.color), label: str(l.label) });
+  });
+  if (plan.milestoneLegend !== false) items.push({ type: "diamond", color: "", label: str(plan.milestoneLabel || "마일스톤") });
+  for (const g of gates) items.push({ type: "gate", color: "C0392B", label: `${g.label || "게이트"}(빨간 수직선 = ${mmdd(g.key)})` });
+  return items;
+}
+
+/** notes: [{ heading, lines }]; lines may also be one string. */
+function notesOf(plan, errors) {
+  return list(plan, "notes", errors).map(obj).map((n, i) => {
+    const lines = typeof n.lines === "string" ? [n.lines] : n.lines ?? [];
+    if (!Array.isArray(lines)) errors.push(`notes[${i}].lines 는 배열이나 글이어야 함`);
+    return { heading: str(n.heading), lines: (Array.isArray(lines) ? lines : []).map(str) };
+  });
+}
+
+function rowsOf(plan, ctx) {
+  if (!Array.isArray(plan.rows) || !plan.rows.length) {
+    ctx.errors.push("rows 가 비어 있음");
+    return [];
+  }
+  return plan.rows.map((r, i) => layRow(obj(r), i, ctx)).filter(Boolean);
+}
+
+function titleOf(plan, range, n) {
+  const sameYear = range.start.slice(0, 4) === range.end.slice(0, 4);
+  const endText = sameYear ? mmdd(range.end) : range.end;
+  const span = `${range.start}(${dowName(range.start)}) ~ ${endText}(${dowName(range.end)})`;
+  return [str(plan.title).trim(), span, `${n} 영업일`, str(plan.subtitle).trim()].filter(Boolean).join("    |    ");
+}
+
+function tooLong(model, errors) {
+  const texts = [
+    model.title, model.sheet, ...model.legend.map((l) => l.label), ...model.rows.flatMap((r) => r.cells.map(str)),
+    ...model.notes.flatMap((n) => [n.heading, ...n.lines]),
+  ];
+  if (texts.some((t) => t.length > MAX_TEXT)) errors.push(`한 칸의 글이 ${MAX_TEXT}자를 넘음(Excel 한도)`);
+}
+
+/**
+ * Checks a plan and lays it out. Returns { errors, warnings, model }; model is null when there are errors.
+ * model: { title, sheet, head, days: [{ key, label, dow }], weeks, gates, rows, legend, notes }
+ */
+export function layout(plan) {
+  const errors = [];
+  const warnings = [];
+  if (!plan || typeof plan !== "object" || Array.isArray(plan)) return { errors: ["plan 은 JSON 객체여야 함"], warnings, model: null };
+  const frame = readFrame(plan, errors, warnings);
+  if (!frame) return { errors, warnings, model: null };
+  const days = businessDays(frame.range.start, frame.range.end, frame.holidays);
+  if (!days.length) errors.push("기간 안에 영업일이 없음");
+  const multiYear = frame.range.start.slice(0, 4) !== frame.range.end.slice(0, 4);
+  const label = (k) => (multiYear ? `${k.slice(2, 4)}/${mmdd(k)}` : mmdd(k));
+  const ctx = { ...frame, errors, label, index: new Map(days.map((k, i) => [k, i])) };
+  const gates = gatesOf(plan, ctx);
+  const rows = rowsOf(plan, ctx);
+  const legend = legendOf(plan, frame.parts, gates, errors);
+  const notes = notesOf(plan, errors);
+  const model = {
+    title: titleOf(plan, frame.range, days.length),
+    sheet: str(plan.sheet || "WBS 간트"),
+    head: HEAD,
+    days: days.map((k) => ({ key: k, label: mmdd(k), dow: dowName(k) })),
+    weeks: weeks(days),
+    gates,
+    rows,
+    legend,
+    notes,
+  };
+  tooLong(model, errors);
+  return { errors, warnings, model: errors.length ? null : model };
+}

package/skills/wbs-gen/scripts/wg-xlsx.mjs

@@ -0,0 +1,328 @@
+// wg-xlsx.mjs: draws the wbs-gen model as one XLSX sheet. Bars are plain cell fills (no conditional formatting), so
+// the file looks the same in any viewer; the parts follow the layout Excel itself writes (shared strings, frozen
+// panes, print titles, A3 landscape fit to one page wide).
+import { zip } from "./wg-zip.mjs";
+
+const NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
+const NSR = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+// Hangul is set in Noto Sans KR and everything else in Noto Sans. A cell that mixes the two holds rich-text runs,
+// one font per run; spaces and punctuation stay in the run they follow. Noto Sans has no geometric shapes, so ◆
+// goes with Noto Sans KR, which has them; so do Hanja, CJK punctuation and full-width forms (Noto Sans has none).
+export const KR = "Noto Sans KR";
+export const LATIN = "Noto Sans";
+const HANGUL = /[\u1100-\u11FF\u2190-\u21FF\u2460-\u24FF\u25A0-\u27BF\u2E80-\u9FFF\uA960-\uA97F\uAC00-\uD7A3\uD7B0-\uD7FF\uF900-\uFAFF\uFF00-\uFFEF※]/;
+const NEUTRAL = /[\s.,·:;()[\]{}\-/|'"!?~]/;
+const GRID = "D5D8DC";
+const GATE = "C0392B";
+const FONTS = {
+  base: { sz: 11, name: LATIN },
+  title: { b: 1, sz: 13, color: "FFFFFF" },
+  head: { b: 1, sz: 10, color: "FFFFFF" },
+  day: { b: 1, sz: 8, color: "2C3E50" },
+  body: { sz: 8, color: "2C3E50" },
+  bodyB: { b: 1, sz: 8, color: "1B2631" },
+  mile: { b: 1, sz: 9, color: GATE },
+  note: { sz: 9, color: "2C3E50" },
+  noteB: { b: 1, sz: 10, color: "1B2631" },
+};
+const WIDTHS = [6, 36, 10.5, 9, 28, 7.5, 7.5, 8.2];
+const DAY_WIDTH = 4.8;
+const ALIGN = ["center", "left", "center", "center", "left", "center", "center", "center"];
+
+// Control characters other than tab and new line are not allowed in XML 1.0.
+const clean = (s) => String(s).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]/g, "");
+export const esc = (s) => clean(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+
+export function colName(i) {
+  let s = "";
+  for (let n = i + 1; n > 0; n = Math.floor((n - 1) / 26)) s = String.fromCharCode(65 + ((n - 1) % 26)) + s;
+  return s;
+}
+
+/** Splits text into runs of one font: [{ text, kr }]. Text with no letters is one Noto Sans run. */
+export function scriptRuns(text) {
+  const runs = [];
+  let lead = "";
+  for (const ch of String(text)) {
+    const last = runs[runs.length - 1];
+    if (NEUTRAL.test(ch)) {
+      if (last) last.text += ch;
+      else lead += ch;
+      continue;
+    }
+    const kr = HANGUL.test(ch);
+    if (last && last.kr === kr) last.text += ch;
+    else runs.push({ text: (last ? "" : lead) + ch, kr });
+  }
+  return runs.length ? runs : [{ text: lead, kr: false }];
+}
+
+/** Sheet names may not hold []:*?/\, start or end with ', be History, or pass 31 characters. */
+export function sheetName(s) {
+  const trim = (x) => x.trim().replace(/^'+|'+$/g, "").trim();
+  let t = trim(clean(s).replace(/[[\]:*?/\\]/g, " "));
+  // 31 UTF-16 units, without cutting a surrogate pair; trim again in case the cut leaves a ' at the end.
+  while (t.length > 31) t = Array.from(t).slice(0, -1).join("");
+  t = trim(t);
+  return !t || /^history$/i.test(t) ? "WBS" : t;
+}
+
+/** Collects the distinct fonts, fills, borders and cell formats a sheet uses. */
+class Styles {
+  constructor() {
+    this.fonts = [FONTS.base];
+    this.fills = ["none", "gray125"];
+    this.borders = [{}];
+    this.xfs = [{ font: 0, fill: 0, border: 0, h: "", wrap: false }];
+    this.seen = new Map();
+  }
+  pick(list, item) {
+    const k = JSON.stringify(item);
+    let i = list.findIndex((x) => JSON.stringify(x) === k);
+    if (i < 0) i = list.push(item) - 1;
+    return i;
+  }
+  /** spec: { font, fill, border: { l, r, t, b }, h, wrap }; kr picks Noto Sans KR for the cell font. */
+  id(spec, kr) {
+    const key = JSON.stringify([spec, kr]);
+    if (this.seen.has(key)) return this.seen.get(key);
+    const xf = {
+      font: this.pick(this.fonts, fontOf(spec, kr)),
+      fill: spec.fill ? this.pick(this.fills, spec.fill) : 0,
+      border: this.pick(this.borders, spec.border ?? {}),
+      h: spec.h ?? "",
+      wrap: !!spec.wrap,
+    };
+    const i = this.pick(this.xfs, xf);
+    this.seen.set(key, i);
+    return i;
+  }
+}
+
+export const fontOf = (spec, kr) => ({ ...(FONTS[spec.font] ?? FONTS.base), name: kr ? KR : LATIN });
+
+const BORDER = { thin: ["thin", GRID], gate: ["medium", GATE], dotted: ["dotted", "7F8C8D"] };
+
+// The inside of <font> (cell fonts, name) and of <rPr> (rich-text runs, rFont): same children, other name tag.
+function fontBody(f, nameTag) {
+  const b = f.b ? "<b/>" : "";
+  const color = `<color rgb="FF${f.color ?? "000000"}"/>`;
+  const charset = f.name === KR ? `<charset val="129"/>` : "";
+  return `${b}<sz val="${f.sz}"/>${color}<${nameTag} val="${f.name}"/><family val="2"/>${charset}`;
+}
+
+const fontXml = (f) => `<font>${fontBody(f, "name")}</font>`;
+
+function fillXml(f) {
+  if (f === "none" || f === "gray125") return `<fill><patternFill patternType="${f}"/></fill>`;
+  return `<fill><patternFill patternType="solid"><fgColor rgb="FF${f}"/><bgColor indexed="64"/></patternFill></fill>`;
+}
+
+function borderXml(b) {
+  const side = (n) => {
+    const v = BORDER[b[n[0]]];
+    return v ? `<${n} style="${v[0]}"><color rgb="FF${v[1]}"/></${n}>` : `<${n}/>`;
+  };
+  return `<border>${["left", "right", "top", "bottom"].map(side).join("")}<diagonal/></border>`;
+}
+
+function xfXml(x) {
+  const flags = `${x.fill ? ' applyFill="1"' : ""}${x.border ? ' applyBorder="1"' : ""}`;
+  const align = x.h || x.wrap
+    ? `<alignment${x.h ? ` horizontal="${x.h}"` : ""} vertical="center"${x.wrap ? ' wrapText="1"' : ""}/>`
+    : "";
+  const open = `<xf numFmtId="0" fontId="${x.font}" fillId="${x.fill}" borderId="${x.border}" xfId="0" applyFont="1"${flags}`;
+  return align ? `${open} applyAlignment="1">${align}</xf>` : `${open}/>`;
+}
+
+function stylesXml(st) {
+  const list = (tag, items, fn) => `<${tag} count="${items.length}">${items.map(fn).join("")}</${tag}>`;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<styleSheet xmlns="${NS}">`
+    + list("fonts", st.fonts, fontXml) + list("fills", st.fills, fillXml) + list("borders", st.borders, borderXml)
+    + `<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>`
+    + list("cellXfs", st.xfs, xfXml)
+    + `<cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles>`
+    + `<dxfs count="0"/><tableStyles count="0" defaultTableStyle="TableStyleMedium2" defaultPivotStyle="PivotStyleLight16"/></styleSheet>`;
+}
+
+/** The sheet being drawn: cells by row, merged ranges, row heights, shared strings. */
+class Sheet {
+  constructor() {
+    this.rows = new Map();
+    this.merges = [];
+    this.heights = new Map();
+    this.strings = [];
+    this.refs = 0;
+    this.stringIndex = new Map();
+    this.styles = new Styles();
+  }
+  put(r, c, value, spec) {
+    if (!this.rows.has(r)) this.rows.set(r, new Map());
+    const runs = typeof value === "string" && value ? scriptRuns(clean(value)) : [{ text: "", kr: false }];
+    const kr = runs.some((x) => x.kr);
+    const mixed = runs.length > 1 ? runs.map((x) => ({ ...x, font: fontOf(spec, x.kr) })) : null;
+    this.rows.get(r).set(c, { value, s: this.styles.id(spec, kr), runs: mixed });
+  }
+  merge(r1, c1, r2, c2) {
+    this.merges.push(`${colName(c1)}${r1}:${colName(c2)}${r2}`);
+  }
+  /** A shared string; mixed runs carry their fonts, so the same text in another cell font is another entry. */
+  sst(text, runs) {
+    const t = clean(text);
+    const key = runs ? `r:${JSON.stringify(runs)}` : `p:${t}`;
+    this.refs++;
+    if (!this.stringIndex.has(key)) this.stringIndex.set(key, this.strings.push({ text: t, runs }) - 1);
+    return this.stringIndex.get(key);
+  }
+  cellXml(r, c, cell) {
+    const ref = `${colName(c)}${r}`;
+    if (typeof cell.value === "number") return `<c r="${ref}" s="${cell.s}"><v>${cell.value}</v></c>`;
+    if (cell.value === "" || cell.value === null || cell.value === undefined) return `<c r="${ref}" s="${cell.s}"/>`;
+    return `<c r="${ref}" s="${cell.s}" t="s"><v>${this.sst(cell.value, cell.runs)}</v></c>`;
+  }
+  dataXml() {
+    const out = [];
+    for (const r of [...this.rows.keys()].sort((a, b) => a - b)) {
+      const cells = this.rows.get(r);
+      const ht = this.heights.get(r);
+      const attr = ht ? ` ht="${ht}" customHeight="1"` : "";
+      const xml = [...cells.keys()].sort((a, b) => a - b).map((c) => this.cellXml(r, c, cells.get(c))).join("");
+      out.push(`<row r="${r}"${attr}>${xml}</row>`);
+    }
+    return out.join("");
+  }
+}
+
+const grid = (gate) => ({ l: gate ? "gate" : "thin", r: "thin", t: "thin", b: "thin" });
+
+function drawHead(sh, m, last) {
+  sh.put(1, 0, m.title, { font: "title", fill: "1F3864", h: "left" });
+  for (let c = 1; c <= last; c++) sh.put(1, c, "", { font: "title", fill: "1F3864" });
+  sh.merge(1, 0, 1, last);
+  sh.heights.set(1, 28).set(2, 16).set(3, 30);
+  m.head.forEach((h, c) => {
+    for (const r of [2, 3]) sh.put(r, c, r === 2 ? h : "", { font: "head", fill: "34495E", border: grid(false), h: "center", wrap: true });
+    sh.merge(2, c, 3, c);
+  });
+  const gateCols = new Set(m.gates.map((g) => g.col));
+  for (const w of m.weeks) {
+    for (let i = w.first; i < w.first + w.count; i++) {
+      sh.put(2, 8 + i, i === w.first ? w.label : "", { font: "head", fill: "5D6D7E", border: grid(gateCols.has(i)), h: "center" });
+    }
+    if (w.count > 1) sh.merge(2, 8 + w.first, 2, 8 + w.first + w.count - 1);
+  }
+  m.days.forEach((d, i) => {
+    sh.put(3, 8 + i, `${d.label}\n${d.dow}`, { font: "day", fill: "EBEDEF", border: grid(gateCols.has(i)), h: "center", wrap: true });
+  });
+}
+
+function dayCell(row, i, gate) {
+  const border = grid(gate);
+  if (row.diamonds.includes(i)) {
+    const b = row.dotted ? { ...border, l: gate ? "gate" : "dotted", r: "dotted", b: "dotted" } : border;
+    return ["◆", { font: "mile", fill: row.fill, border: b, h: "center" }];
+  }
+  const fill = i >= row.from && i <= row.to ? row.bar : row.fill;
+  return ["", { font: "body", fill, border }];
+}
+
+function drawRows(sh, m) {
+  const gateCols = new Set(m.gates.map((g) => g.col));
+  m.rows.forEach((row, n) => {
+    const r = 4 + n;
+    const font = row.kind === "group" ? "bodyB" : "body";
+    row.cells.forEach((v, c) => {
+      sh.put(r, c, v, { font, fill: row.fill, border: grid(false), h: ALIGN[c], wrap: c === 1 || c === 4 });
+    });
+    m.days.forEach((_, i) => {
+      const [v, spec] = dayCell(row, i, gateCols.has(i));
+      sh.put(r, 8 + i, v, spec);
+    });
+  });
+  return 4 + m.rows.length;
+}
+
+function legendCell(item) {
+  if (item.type === "diamond") return ["◆", { font: "mile", h: "center" }];
+  if (item.type === "gate") return ["", { font: "note", border: { l: "gate", r: "gate" } }];
+  const b = item.type === "dotted" ? { l: "dotted", r: "dotted", t: "dotted", b: "dotted" } : grid(false);
+  return ["", { font: "note", fill: item.color, border: b }];
+}
+
+function drawNotes(sh, m, start) {
+  let r = start + 1;
+  if (m.legend.length) {
+    sh.put(r++, 0, "[범례]", { font: "noteB" });
+    for (const item of m.legend) {
+      const [v, spec] = legendCell(item);
+      sh.put(r, 0, v, spec);
+      sh.put(r++, 1, item.label, { font: "note" });
+    }
+  }
+  for (const n of m.notes) {
+    r++;
+    if (n.heading) sh.put(r++, 0, n.heading, { font: "noteB" });
+    for (const line of n.lines) sh.put(r++, 0, line, { font: "note" });
+  }
+  return r - 1;
+}
+
+function sheetXml(sh, last, lastRow) {
+  const cols = WIDTHS.map((w, i) => `<col min="${i + 1}" max="${i + 1}" width="${w}" customWidth="1"/>`).join("")
+    + `<col min="9" max="${last + 1}" width="${DAY_WIDTH}" customWidth="1"/>`;
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<worksheet xmlns="${NS}" xmlns:r="${NSR}">`
+    + `<sheetPr><pageSetUpPr fitToPage="1"/></sheetPr><dimension ref="A1:${colName(last)}${lastRow}"/>`
+    + `<sheetViews><sheetView tabSelected="1" workbookViewId="0"><pane xSplit="8" ySplit="3" topLeftCell="I4" activePane="bottomRight" state="frozen"/>`
+    + `<selection pane="topRight"/><selection pane="bottomLeft"/><selection pane="bottomRight" activeCell="I4" sqref="I4"/></sheetView></sheetViews>`
+    + `<sheetFormatPr defaultRowHeight="16.5"/><cols>${cols}</cols><sheetData>${sh.dataXml()}</sheetData>`
+    + `<mergeCells count="${sh.merges.length}">${sh.merges.map((x) => `<mergeCell ref="${x}"/>`).join("")}</mergeCells>`
+    + `<printOptions horizontalCentered="1"/><pageMargins left="0.4" right="0.4" top="0.5" bottom="0.5" header="0.3" footer="0.3"/>`
+    + `<pageSetup paperSize="8" orientation="landscape" fitToWidth="1" fitToHeight="0"/></worksheet>`;
+}
+
+function sstXml(strings, refs) {
+  const run = (x) => `<r><rPr>${fontBody(x.font, "rFont")}</rPr><t xml:space="preserve">${esc(x.text)}</t></r>`;
+  const si = strings.map((s) => (s.runs ? `<si>${s.runs.map(run).join("")}</si>` : `<si><t xml:space="preserve">${esc(s.text)}</t></si>`)).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<sst xmlns="${NS}" count="${refs}" uniqueCount="${strings.length}">${si}</sst>`;
+}
+
+function packageParts(name) {
+  const quoted = `'${name.replace(/'/g, "''")}'`;
+  return {
+    types: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">`
+      + `<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/>`
+      + `<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>`
+      + `<Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`
+      + `<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>`
+      + `<Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/></Types>`,
+    rels: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`
+      + `<Relationship Id="rId1" Type="${NSR}/officeDocument" Target="xl/workbook.xml"/></Relationships>`,
+    workbook: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<workbook xmlns="${NS}" xmlns:r="${NSR}">`
+      + `<bookViews><workbookView/></bookViews><sheets><sheet name="${esc(name)}" sheetId="1" r:id="rId1"/></sheets>`
+      + `<definedNames><definedName name="_xlnm.Print_Titles" localSheetId="0">${esc(quoted)}!$1:$3</definedName></definedNames></workbook>`,
+    wbRels: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">`
+      + `<Relationship Id="rId1" Type="${NSR}/worksheet" Target="worksheets/sheet1.xml"/>`
+      + `<Relationship Id="rId2" Type="${NSR}/styles" Target="styles.xml"/>`
+      + `<Relationship Id="rId3" Type="${NSR}/sharedStrings" Target="sharedStrings.xml"/></Relationships>`,
+  };
+}
+
+/** Returns the XLSX bytes for a layout model. */
+export function toXlsx(m) {
+  const sh = new Sheet();
+  const last = 7 + m.days.length;
+  drawHead(sh, m, last);
+  const lastRow = drawNotes(sh, m, drawRows(sh, m));
+  const sheet = sheetXml(sh, last, lastRow);
+  const name = sheetName(m.sheet);
+  const p = packageParts(name);
+  return zip([
+    { name: "[Content_Types].xml", data: p.types },
+    { name: "_rels/.rels", data: p.rels },
+    { name: "xl/workbook.xml", data: p.workbook },
+    { name: "xl/_rels/workbook.xml.rels", data: p.wbRels },
+    { name: "xl/worksheets/sheet1.xml", data: sheet },
+    { name: "xl/styles.xml", data: stylesXml(sh.styles) },
+    { name: "xl/sharedStrings.xml", data: sstXml(sh.strings, sh.refs) },
+  ]);
+}