palette-docs 0.0.0-stage → 0.1.0

package/NOTICE.md

@@ -0,0 +1,8 @@
+# Notice
+
+- `vendor/hwpx/blank.hwpx` is the blank document template from hwpxlib (https://github.com/neolord0/hwpxlib,
+  `testFile/tool`), Apache License 2.0. New HWPX files are built on it so 한글 opens them as native documents.
+- The HWP 5.0 reader, HWPX reader/writer and the DOCX/XLSX writers were first written for Palette Island
+  (same author) and ported to Node here.
+- Dependencies keep their own licences: @modelcontextprotocol/sdk, fast-xml-parser, heic-convert, jszip, mammoth,
+  pdf-parse, pptxgenjs, sharp (Apache-2.0; bundles libvips, LGPL-3.0), turndown, turndown-plugin-gfm, xlsx (Apache-2.0), zod.

package/README.md

@@ -1,3 +1,40 @@
-# Temporary Holding Version
+# Palette Docs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Documents and images for Palette Code: an MCP server (`palette-docs mcp`) and a CLI, no native toolchain needed.
+
+**Read** (markdown out, tables kept): `hwp` `hwpx` `docx` `doc` `rtf` `odt` `xlsx` `xlsm` `xls` `ods` `csv` `tsv` `pptx`
+`ppt` `odp` `pdf` `html` `txt` `md` `json` `xml` `yaml`, and `zip` (expands up to 20 files). Up to 20 files per call.
+
+**Images as references**: `png` `jpg` `webp` `gif` `bmp` `tiff` `heic` `svg` `avif` → EXIF-rotated, resized to 1568 px,
+returned as an image block the vision seats (`palette-llm-max`, `palette-llm-fast`) can see. Images embedded in
+hwp/hwpx/docx/pptx/xlsx/zip can be pulled out as files.
+
+**Create** from markdown (headings, paragraphs, bullets, numbered lists, tables, code): `docx` `hwpx` `xlsx` `pptx`
+`md` `txt` `csv` `html` natively; `pdf` `doc` `xls` `ppt` `odt` `ods` `odp` `rtf` through LibreOffice when it is
+installed. `hwp` (binary 5.0) cannot be written: create `hwpx`, which 한글 opens as a native document (the file starts
+from Hancom's own blank template, with real tables, shaded header rows and repeated headers).
+
+Fonts: `font` picks the family for docx/xlsx/pptx/html (default 맑은 고딕 / Malgun Gothic; Noto Sans KR, Apple SD
+Gothic Neo, 나눔고딕 work the same way). HWPX keeps Hancom's default faces.
+
+```bash
+npm i -g palette-docs
+palette-docs read 제안서.hwp                       # markdown on stdout
+palette-docs create 보고서.hwpx 보고서.md --title "3분기 보고서"
+palette-docs create 보고서.pdf 보고서.md            # needs LibreOffice
+palette-docs convert 제안서.hwpx docx
+palette-docs image IMG_0042.heic                   # IMG_0042.normalized.jpg
+palette-docs formats
+```
+
+Palette Code pre-configures the server as `docs` in `palette-code.json`:
+
+```json
+"docs": { "type": "local", "command": ["palette-docs", "mcp"], "enabled": true, "codemode": false }
+```
+
+Tools: `read_document`, `read_documents`, `read_image`, `extract_images`, `create_document`, `convert_document`,
+`list_formats`. Tests: `node test/run.mjs` (real HWP/HWPX samples, every writer read back, images, zip, LibreOffice,
+MCP round trip).
+
+MIT. See `NOTICE.md`.

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "palette-docs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Palette Docs: lets Palette Code read HWP/HWPX/DOCX/XLSX/PPTX/PDF/ZIP and images, and create DOCX/HWPX/XLSX/PPTX (PDF and legacy formats via LibreOffice). MCP server + CLI.",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.32.1",
+    "fast-xml-parser": "5.11.2",
+    "heic-convert": "2.1.0",
+    "jszip": "3.10.2",
+    "mammoth": "1.13.0",
+    "pdf-parse": "2.4.5",
+    "pptxgenjs": "4.0.1",
+    "sharp": "0.35.5",
+    "turndown": "7.2.0",
+    "turndown-plugin-gfm": "1.0.2",
+    "xlsx": "0.18.5",
+    "zod": "^4.6.7"
+  },
+  "type": "module",
+  "bin": {
+    "palette-docs": "src/index.js",
+    "pdocs": "src/index.js"
+  },
+  "files": [
+    "src/",
+    "vendor/",
+    "skills/",
+    "README.md",
+    "NOTICE.md"
+  ],
+  "homepage": "https://llm.pltt.dev/docs",
+  "engines": {
+    "node": ">=18.17"
+  }
+}

package/skills/palette-docs/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: palette-docs
+description: Reading and creating office documents and images with Palette Docs (MCP server "docs"): HWP/HWPX/DOCX/XLSX/PPTX/PDF/ZIP inputs, image references (png/jpg/webp/heic/svg/…), and DOCX/HWPX/XLSX/PPTX/PDF outputs from markdown. Use when a user attaches or names a document, spreadsheet, deck, PDF, archive or image, or asks for a 한글/Word/Excel/PowerPoint/PDF file.
+---
+
+# Palette Docs
+
+## Reading
+- One file: `read_document(path)`. Several (max 20): `read_documents(paths)`. A `.zip` is expanded (first 20 readable files).
+- The result is markdown: sheets and slides are headed (`## Sheet`, `## Slide 3`), tables are markdown tables. Quote numbers from it exactly.
+- Long files are truncated at `max_chars` (default 60k); raise it or ask for a section rather than guessing.
+- `.hwp` encrypted documents cannot be read; say so and ask for an unlocked copy or HWPX.
+- Legacy `.doc/.ppt/.xls/.rtf/.odt` need LibreOffice on the machine (`list_formats` shows `libreoffice: true/false`).
+
+## Images as references
+- Use `read_image(path)` for any picture (png, jpg, webp, gif, bmp, tiff, heic, svg, avif); it returns the image to the model. Needs a vision seat: `palette-llm-max` or `palette-llm-fast`.
+- Pictures inside a document: `extract_images(path)` then `read_image` on the ones that matter.
+
+## Creating
+- Write the content as markdown first (headings `#`/`##`, bullets, numbered lists, pipe tables, fenced code), then
+  `create_document({ path, markdown, title, font? })`; the extension picks the format: `.docx .hwpx .xlsx .pptx .md .csv .html`,
+  and `.pdf .doc .xls .ppt .odt .ods .odp .rtf` when LibreOffice is installed.
+- Korean government / public-sector / 한글 users: create `.hwpx` (한글 native). `.hwp` binary export is not available; say so instead of promising it.
+- Spreadsheets: each markdown table becomes a sheet named after the heading above it; percentages and numbers become real cells.
+- Decks: each `##` heading becomes a slide; keep 7 bullets or fewer per heading; tables get their own slide.
+- `font` (docx/xlsx/pptx/html): default 맑은 고딕. Use the user's font if they name one.
+- Put outputs next to the source or where the user said; report the absolute path.
+
+## Converting
+- `convert_document({ path, to })` — e.g. hwpx→docx, docx→pdf, xlsx→csv, pptx→pdf. Native when possible, LibreOffice otherwise.

package/src/blocks.js

@@ -0,0 +1,118 @@
+// Markdown -> blocks shared by every writer.
+// [{type:'h',level,text} | {type:'p',text} | {type:'li',n?,text} | {type:'table',rows}]
+// Ported from Palette Island ui/export.js (same owner); chart blocks are not carried over.
+
+export const esc = (s) => String(s).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;")
+
+export const plain = (s) =>
+  String(s)
+    .replace(/\*\*(.+?)\*\*/g, "$1")
+    .replace(/(^|[^\\])\*(.+?)\*/g, "$1$2")
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+    .replace(/\\([*_])/g, "$1")
+    .trim()
+
+export function blocksOf(md) {
+  const src = String(md).replace(/<details>[\s\S]*?<\/details>/g, "")
+  const out = []
+  const lines = src.split("\n")
+  let inFence = false
+  let fence = []
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i]
+    if (/^\s*```/.test(raw)) {
+      if (inFence) {
+        out.push({ type: "code", text: fence.join("\n") })
+        fence = []
+      }
+      inFence = !inFence
+      continue
+    }
+    if (inFence) {
+      fence.push(raw)
+      continue
+    }
+    const l = raw.replace(/^\s*>\s?/, "")
+    if (/^\s*([-*_])\1{2,}\s*$/.test(l)) continue
+    if (/^\s*\|.*\|\s*$/.test(l)) {
+      const rows = []
+      while (i < lines.length && /^\s*\|.*\|\s*$/.test(lines[i])) {
+        if (!/^\s*\|[\s:|-]+\|\s*$/.test(lines[i]))
+          rows.push(
+            lines[i]
+              .trim()
+              .replace(/^\||\|$/g, "")
+              .split("|")
+              .map((c) => plain(c)),
+          )
+        i++
+      }
+      i--
+      if (rows.length) out.push({ type: "table", rows })
+      continue
+    }
+    const h = l.match(/^(#{1,4})\s+(.*)/)
+    if (h) {
+      out.push({ type: "h", level: h[1].length, text: plain(h[2]) })
+      continue
+    }
+    const o = l.match(/^\s*(\d+)[.)]\s+(.*)/)
+    if (o) {
+      out.push({ type: "li", n: +o[1], text: plain(o[2]) })
+      continue
+    }
+    const b = l.match(/^\s*[-*•]\s+(.*)/)
+    if (b) {
+      out.push({ type: "li", text: plain(b[1]) })
+      continue
+    }
+    if (/^\*\*[^*]+\*\*:?\s*$/.test(l.trim())) {
+      out.push({ type: "h", level: 3, text: plain(l) })
+      continue
+    }
+    if (l.trim()) out.push({ type: "p", text: plain(l) })
+  }
+  if (inFence && fence.length) out.push({ type: "code", text: fence.join("\n") })
+  return out
+}
+
+export const isNum = (v) => /^[-+(]?[₩$]?\s?[\d,]+(\.\d+)?\s?(%|원|천원|만원|억원|백만원|배|x)?\)?$/.test(String(v).trim())
+
+export const today = () => {
+  const d = new Date()
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`
+}
+
+/** Columns whose body cells are mostly numbers: right-aligned, header included. */
+export const numCols = (rows) => {
+  const body = rows.slice(1)
+  const n = Math.max(0, ...rows.map((r) => r.length))
+  return Array.from({ length: n }, (_, ci) => {
+    const v = body.map((r) => r[ci]).filter((c) => c != null && String(c).trim())
+    return v.length > 0 && v.filter(isNum).length / v.length >= 0.6
+  })
+}
+
+export const marker = (k) => (k.n != null ? `${k.n}.` : "•")
+
+/** Blocks back to markdown (used for md/txt outputs and for the read side). */
+export function toMarkdown(blocks) {
+  const out = []
+  for (const k of blocks) {
+    if (k.type === "h") out.push(`${"#".repeat(k.level)} ${k.text}`, "")
+    else if (k.type === "li") out.push(`${k.n != null ? `${k.n}.` : "-"} ${k.text}`)
+    else if (k.type === "p") out.push(k.text, "")
+    else if (k.type === "code") out.push("```", k.text, "```", "")
+    else if (k.type === "table") out.push(mdTable(k.rows), "")
+  }
+  return out.join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n"
+}
+
+export function mdTable(rows) {
+  if (!rows.length) return ""
+  const n = Math.max(...rows.map((r) => r.length))
+  const cell = (c) => String(c ?? "").replace(/\|/g, "\\|").replace(/\n+/g, " ").trim()
+  const line = (r) => `| ${Array.from({ length: n }, (_, i) => cell(r[i])).join(" | ")} |`
+  return [line(rows[0]), `| ${Array.from({ length: n }, () => "---").join(" | ")} |`, ...rows.slice(1).map(line)].join("\n")
+}

package/src/hwp.js

@@ -0,0 +1,205 @@
+// Hangul word processor files, read with no native code.
+//   .hwpx  a zip of XML: Contents/section*.xml; paragraphs <hp:p>, text <hp:t>, tables <hp:tbl>, pictures <hp:pic>
+//   .hwp   HWP 5.x: an OLE2 compound file; BodyText/Section* streams, raw-deflated when the FileHeader says so,
+//          made of records whose tag 67 (HWPTAG_PARA_TEXT) carries UTF-16LE text with control characters.
+// Ported from Palette Island ui/hwp.js (same owner) to Node: zlib instead of DecompressionStream, fast-xml-parser
+// instead of DOMParser, and tables are rendered instead of flattened.
+import zlib from "node:zlib"
+import JSZip from "jszip"
+import { XMLParser } from "fast-xml-parser"
+import { mdTable } from "./blocks.js"
+
+const naturalSort = (a, b) => a.localeCompare(b, undefined, { numeric: true })
+
+// ---------- HWPX ----------
+const parser = new XMLParser({ preserveOrder: true, ignoreAttributes: false, attributeNamePrefix: "@_", trimValues: false, parseTagValue: false })
+
+const tagOf = (node) => Object.keys(node).find((k) => k !== ":@")
+const kids = (node) => node[tagOf(node)] || []
+
+/** Text of every <hp:t> below `node`, skipping nested tables (they are rendered on their own). */
+function textOf(node, textTag, skipTags) {
+  const tag = tagOf(node)
+  if (tag === "#text") return String(node["#text"])
+  if (skipTags.has(tag)) return ""
+  if (tag === "hp:tab") return "\t"
+  if (tag === "hp:lineBreak") return "\n"
+  if (!Array.isArray(node[tag])) return ""
+  return node[tag].map((c) => textOf(c, textTag, skipTags)).join("")
+}
+
+function findAll(node, tag, out = [], stopAt = new Set()) {
+  const t = tagOf(node)
+  if (t === tag) out.push(node)
+  if (stopAt.has(t) && t !== tag) return out
+  if (Array.isArray(node[t])) for (const c of node[t]) findAll(c, tag, out, stopAt)
+  return out
+}
+
+/** One paragraph (any nesting) -> markdown lines; tables inside the paragraph come out as markdown tables. */
+function renderPara(p, opts) {
+  const { textTag, tableTag, rowTag, cellTag, paraTag } = opts
+  const skip = new Set([tableTag, "hp:pic", "hp:secPr", "hp:ctrl", "hp:container"])
+  const lines = []
+  const text = textOf(p, textTag, skip).replace(/\n+$/, "")
+  if (text.trim()) lines.push(text)
+  for (const tbl of findAll(p, tableTag, [], new Set([tableTag]))) {
+    const rows = []
+    for (const tr of findAll(tbl, rowTag, [], new Set([rowTag]))) {
+      const cells = []
+      for (const tc of findAll(tr, cellTag, [], new Set([cellTag]))) {
+        const paras = findAll(tc, paraTag, [], new Set([tableTag]))
+        const inner = paras.length ? paras : [tc]
+        cells.push(inner.map((ip) => renderPara(ip, opts).join(" ")).filter(Boolean).join(" "))
+      }
+      rows.push(cells)
+    }
+    if (rows.length) lines.push("", mdTable(rows), "")
+  }
+  return lines
+}
+
+export async function hwpxRead(buffer) {
+  const zip = await JSZip.loadAsync(buffer)
+  const names = Object.keys(zip.files).filter((f) => /^Contents\/section\d+\.xml$/i.test(f)).sort(naturalSort)
+  const parts = []
+  const opts = { textTag: "hp:t", tableTag: "hp:tbl", rowTag: "hp:tr", cellTag: "hp:tc", paraTag: "hp:p" }
+  for (const f of names) {
+    const tree = parser.parse(await zip.file(f).async("string"))
+    const sec = findAll({ root: tree }, "hs:sec")[0]
+    const top = sec ? kids(sec).filter((n) => tagOf(n) === "hp:p") : findAll({ root: tree }, "hp:p")
+    const lines = []
+    for (const p of top) lines.push(...renderPara(p, opts))
+    parts.push(lines.join("\n").replace(/\n{3,}/g, "\n\n").trim())
+  }
+  const images = Object.keys(zip.files).filter((f) => /^BinData\//i.test(f) && !zip.files[f].dir)
+  let title = ""
+  const hpf = zip.file("Contents/content.hpf")
+  if (hpf) title = ((await hpf.async("string")).match(/<opf:title>([^<]*)<\/opf:title>/) || [])[1] || ""
+  return { text: parts.join("\n\n"), sections: names.length, images, title }
+}
+
+export async function hwpxImages(buffer) {
+  const zip = await JSZip.loadAsync(buffer)
+  const out = []
+  for (const f of Object.keys(zip.files).filter((f) => /^BinData\//i.test(f) && !zip.files[f].dir))
+    out.push({ name: f.split("/").pop(), data: await zip.file(f).async("nodebuffer") })
+  return out
+}
+
+// ---------- minimal OLE2 / CFB reader ----------
+function cfb(buf) {
+  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+  const u8 = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength)
+  if (dv.getUint32(0, true) !== 0xe011cfd0 || dv.getUint32(4, true) !== 0xe11ab1a1) throw new Error("not an OLE file")
+  const ss = 1 << dv.getUint16(30, true), mss = 1 << dv.getUint16(32, true)
+  const nFat = dv.getUint32(44, true), dirStart = dv.getUint32(48, true), cutoff = dv.getUint32(56, true)
+  const miniFatStart = dv.getUint32(60, true), nMiniFat = dv.getUint32(64, true), difatStart = dv.getUint32(68, true), nDifat = dv.getUint32(72, true)
+  const sector = (n) => u8.subarray(512 + n * ss, 512 + (n + 1) * ss)
+  const u32s = (bytes) => { const out = []; const d = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength); for (let i = 0; i + 4 <= bytes.byteLength; i += 4) out.push(d.getUint32(i, true)); return out }
+  let difat = []
+  for (let i = 0; i < 109; i++) difat.push(dv.getUint32(76 + i * 4, true))
+  let ds = difatStart
+  for (let k = 0; k < nDifat && ds < 0xfffffffa; k++) { const e = u32s(sector(ds)); difat = difat.concat(e.slice(0, -1)); ds = e[e.length - 1] }
+  const fat = []
+  for (const s of difat.slice(0, nFat)) if (s < 0xfffffffa) fat.push(...u32s(sector(s)))
+  const chain = (start, table) => { const out = []; let s = start; let guard = 0; while (s < 0xfffffffa && guard++ < 1e6) { out.push(s); s = table[s] } return out }
+  const readChain = (start) => { const secs = chain(start, fat); const out = new Uint8Array(secs.length * ss); secs.forEach((s, i) => out.set(sector(s), i * ss)); return out }
+  const dirBytes = readChain(dirStart)
+  const entries = []
+  for (let off = 0; off + 128 <= dirBytes.length; off += 128) {
+    const d = new DataView(dirBytes.buffer, dirBytes.byteOffset + off, 128)
+    const nlen = d.getUint16(64, true), type = d.getUint8(66)
+    if (!type) continue
+    let name = ""
+    for (let i = 0; i + 1 < nlen - 1; i += 2) name += String.fromCharCode(d.getUint16(i, true))
+    entries.push({ idx: off / 128, name, type, left: d.getUint32(68, true), right: d.getUint32(72, true), child: d.getUint32(76, true), start: d.getUint32(116, true), size: d.getUint32(120, true) })
+  }
+  const byIdx = {}
+  entries.forEach((e) => (byIdx[e.idx] = e))
+  const root = entries.find((e) => e.type === 5)
+  const miniStream = root && root.size ? readChain(root.start) : new Uint8Array(0)
+  const miniFat = []
+  for (const s of chain(miniFatStart, fat).slice(0, nMiniFat)) miniFat.push(...u32s(sector(s)))
+  const readStream = (e) => {
+    if (e.size >= cutoff) return readChain(e.start).subarray(0, e.size)
+    const secs = chain(e.start, miniFat)
+    const out = new Uint8Array(secs.length * mss)
+    secs.forEach((s, i) => out.set(miniStream.subarray(s * mss, (s + 1) * mss), i * mss))
+    return out.subarray(0, e.size)
+  }
+  const siblings = (idx) => { const out = []; const walk = (i) => { const e = byIdx[i]; if (!e) return; walk(e.left); out.push(e); walk(e.right) }; walk(idx); return out }
+  const find = (path) => { let scope = root ? siblings(root.child) : []; let e = null; for (const seg of path) { e = scope.find((x) => x.name === seg); if (!e) return null; scope = siblings(e.child) } return e }
+  const list = (storage) => { const e = find([storage]); return e ? siblings(e.child).filter((x) => x.type === 2) : [] }
+  return { find, list, readStream }
+}
+
+/** HWP sections are raw deflate streams that often carry trailing bytes; keep what inflates. */
+function inflateRaw(bytes) {
+  try {
+    return zlib.inflateRawSync(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength), { finishFlush: zlib.constants.Z_SYNC_FLUSH })
+  } catch (e) {
+    return zlib.inflateRawSync(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength), { finishFlush: zlib.constants.Z_FULL_FLUSH })
+  }
+}
+
+function paraText(rec) {
+  const n = rec.byteLength >> 1
+  const d = new DataView(rec.buffer, rec.byteOffset, n * 2)
+  let out = ""
+  let j = 0
+  while (j < n) {
+    const c = d.getUint16(j * 2, true)
+    if (c >= 32) { out += String.fromCharCode(c); j += 1 }
+    else if (c === 10 || c === 13) { out += "\n"; j += 1 }
+    else if (c === 30 || c === 31) { out += " "; j += 1 }
+    else if (c === 0 || (c >= 24 && c <= 29)) { j += 1 }
+    else { j += 8 } // inline (4-9, 19-20) and extended (1-3, 11-12, 14-18, 21-23) controls occupy 8 code units
+  }
+  return out
+}
+
+function hwpOpen(buffer) {
+  const doc = cfb(buffer)
+  const header = doc.find(["FileHeader"])
+  if (!header) throw new Error("HWP header missing")
+  const hb = doc.readStream(header)
+  const flags = new DataView(hb.buffer, hb.byteOffset, hb.byteLength).getUint32(36, true)
+  if (flags & 2) throw new Error("encrypted HWP documents cannot be read")
+  return { doc, compressed: !!(flags & 1), distribution: !!(flags & 4) }
+}
+
+export function hwpRead(buffer) {
+  const { doc, compressed } = hwpOpen(buffer)
+  const sections = doc.list("BodyText").filter((e) => /^Section\d+$/.test(e.name)).sort((a, b) => Number(a.name.slice(7)) - Number(b.name.slice(7)))
+  const out = []
+  for (const s of sections) {
+    let data = doc.readStream(s)
+    if (compressed) { try { data = inflateRaw(data) } catch { continue } }
+    const dv = new DataView(data.buffer, data.byteOffset, data.byteLength)
+    let i = 0
+    const paras = []
+    while (i + 4 <= data.byteLength) {
+      const h = dv.getUint32(i, true); i += 4
+      const tag = h & 0x3ff
+      let size = (h >>> 20) & 0xfff
+      if (size === 0xfff) { if (i + 4 > data.byteLength) break; size = dv.getUint32(i, true); i += 4 }
+      if (tag === 67) paras.push(paraText(data.subarray(i, i + size)))
+      i += size
+    }
+    out.push(paras.map((p) => p.replace(/\n+$/, "")).filter((p) => p.trim()).join("\n"))
+  }
+  const images = doc.list("BinData").map((e) => e.name)
+  return { text: out.join("\n\n"), sections: sections.length, images }
+}
+
+export function hwpImages(buffer) {
+  const { doc, compressed } = hwpOpen(buffer)
+  const out = []
+  for (const e of doc.list("BinData")) {
+    let data = doc.readStream(e)
+    if (compressed) { try { data = inflateRaw(data) } catch { continue } }
+    out.push({ name: e.name, data: Buffer.from(data.buffer, data.byteOffset, data.byteLength) })
+  }
+  return out
+}

package/src/image.js

@@ -0,0 +1,85 @@
+// Images as references: any common format -> a model-ready PNG/JPEG (resized, EXIF-rotated), and images embedded in
+// documents pulled out as files.
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import JSZip from "jszip"
+import { hwpImages, hwpxImages } from "./hwp.js"
+import { extOf } from "./read.js"
+
+const PHOTO = new Set(["jpg", "jpeg", "heic", "heif", "avif"])
+
+export async function normalizeImage(file, { maxSide = 1568 } = {}) {
+  if (!fs.existsSync(file)) throw new Error(`no such file: ${file}`)
+  const sharp = (await import("sharp")).default
+  const ext = extOf(file)
+  let input = fs.readFileSync(file)
+  let decodedVia = "sharp"
+  let pipeline
+  if (ext === "heic" || ext === "heif") {
+    // prebuilt sharp ships libheif without an HEVC decoder, so iPhone HEIC always goes through heic-convert (wasm libde265)
+    const convert = (await import("heic-convert")).default
+    input = Buffer.from(await convert({ buffer: input, format: "JPEG", quality: 0.92 }))
+    decodedVia = "heic-convert"
+    pipeline = sharp(input)
+  } else if (ext === "bmp" || input.slice(0, 2).toString() === "BM") {
+    // libvips has no BMP loader in the prebuilt binaries: decode uncompressed 24/32-bit BMP here (the common case)
+    const raw = decodeBmp(input)
+    decodedVia = "bmp-decoder"
+    pipeline = sharp(raw.data, { raw: { width: raw.width, height: raw.height, channels: 4 } })
+  } else {
+    pipeline = sharp(input, ext === "svg" ? { density: 192 } : {})
+    await pipeline.metadata()
+  }
+  const meta = await pipeline.metadata()
+  const photo = PHOTO.has(ext) || meta.format === "jpeg"
+  let out = pipeline.rotate().resize({ width: maxSide, height: maxSide, fit: "inside", withoutEnlargement: true })
+  out = photo ? out.jpeg({ quality: 88 }) : out.png({ compressionLevel: 8 })
+  const data = await out.toBuffer()
+  const outMeta = await sharp(data).metadata()
+  return { data, mimeType: photo ? "image/jpeg" : "image/png", width: outMeta.width, height: outMeta.height, original: { format: meta.format || ext, width: meta.width, height: meta.height, bytes: input.length }, decodedVia }
+}
+
+/** Uncompressed 24/32-bit BMP (BITMAPINFOHEADER, BI_RGB or BI_BITFIELDS with the default masks) -> RGBA. */
+function decodeBmp(buf) {
+  if (buf.slice(0, 2).toString() !== "BM") throw new Error("not a BMP file")
+  const off = buf.readUInt32LE(10), hdr = buf.readUInt32LE(14)
+  const width = buf.readInt32LE(18), heightRaw = buf.readInt32LE(22), bpp = buf.readUInt16LE(28), comp = buf.readUInt32LE(30)
+  if (hdr < 40 || ![24, 32].includes(bpp) || ![0, 3].includes(comp)) throw new Error(`unsupported BMP (${bpp}-bit, compression ${comp}); convert it to PNG first`)
+  const height = Math.abs(heightRaw), topDown = heightRaw < 0
+  const stride = Math.floor((bpp * width + 31) / 32) * 4
+  const data = Buffer.alloc(width * height * 4)
+  for (let y = 0; y < height; y++) {
+    const srcRow = off + (topDown ? y : height - 1 - y) * stride
+    for (let x = 0; x < width; x++) {
+      const s = srcRow + x * (bpp / 8), d = (y * width + x) * 4
+      data[d] = buf[s + 2]; data[d + 1] = buf[s + 1]; data[d + 2] = buf[s]; data[d + 3] = bpp === 32 ? buf[s + 3] || 255 : 255
+    }
+  }
+  return { width, height, data }
+}
+
+const OOXML_MEDIA = { docx: /^word\/media\//, pptx: /^ppt\/media\//, xlsx: /^xl\/media\// }
+
+export async function extractImages(file, outDir) {
+  if (!fs.existsSync(file)) throw new Error(`no such file: ${file}`)
+  const ext = extOf(file)
+  const dir = outDir || fs.mkdtempSync(path.join(os.tmpdir(), "palette-docs-img-"))
+  fs.mkdirSync(dir, { recursive: true })
+  let items = []
+  if (ext === "hwp") items = hwpImages(fs.readFileSync(file))
+  else if (ext === "hwpx") items = await hwpxImages(fs.readFileSync(file))
+  else if (OOXML_MEDIA[ext] || ext === "zip") {
+    const zip = await JSZip.loadAsync(fs.readFileSync(file))
+    const re = OOXML_MEDIA[ext] || /\.(png|jpe?g|gif|webp|bmp|tiff?|heic|svg)$/i
+    for (const name of Object.keys(zip.files).filter((n) => !zip.files[n].dir && re.test(n)))
+      items.push({ name: name.split("/").pop(), data: await zip.file(name).async("nodebuffer") })
+  } else throw new Error(`extract_images supports hwp, hwpx, docx, pptx, xlsx, zip (got .${ext})`)
+  const written = []
+  for (const it of items) {
+    const out = path.join(dir, it.name.replace(/[^\w.-]+/g, "_"))
+    fs.writeFileSync(out, it.data)
+    written.push({ path: out, bytes: it.data.length })
+  }
+  return { dir, images: written }
+}

package/src/index.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+// Palette Docs: documents and images for Palette Code. `palette-docs mcp` serves the tools over stdio; the other
+// subcommands do the same work from a shell.
+import fs from "node:fs"
+import path from "node:path"
+import { readDocument, readDocuments, formatsTable, MAX_ARCHIVE_FILES } from "./read.js"
+import { normalizeImage, extractImages } from "./image.js"
+import { createDocument, convertDocument, NATIVE, VIA_LO, DEFAULT_FONT } from "./write.js"
+
+const VERSION = "0.1.0"
+
+async function mcp() {
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js")
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js")
+  const { z } = await import("zod")
+  const server = new McpServer({ name: "palette-docs", version: VERSION })
+  const text = (t) => ({ content: [{ type: "text", text: t }] })
+  const fail = (e) => ({ content: [{ type: "text", text: `error: ${e.message}` }], isError: true })
+  const header = (r) => `# ${path.basename(r.file)} (${r.format}, ${r.bytes} B, ${r.chars} chars${r.truncated ? ", truncated" : ""}${Object.entries(r.meta || {}).filter(([, v]) => v != null && typeof v !== "object").map(([k, v]) => `, ${k}=${v}`).join("")})\n\n`
+
+  server.registerTool("read_document", {
+    title: "Read a document",
+    description: `Read one file as markdown text: ${["hwp", "hwpx", "docx", "doc", "rtf", "odt", "xlsx", "xls", "csv", "pptx", "ppt", "pdf", "html", "txt", "md", "json"].join(", ")} and zip (expands up to ${MAX_ARCHIVE_FILES} files). Tables come back as markdown tables; sheets and slides are headed. For images use read_image.`,
+    inputSchema: { path: z.string().describe("absolute or relative file path"), max_chars: z.number().int().positive().optional().describe("default 60000") },
+  }, async ({ path: p, max_chars }) => {
+    try { const r = await readDocument(p, { maxChars: max_chars }); return text(header(r) + r.text) } catch (e) { return fail(e) }
+  })
+
+  server.registerTool("read_documents", {
+    title: "Read several documents",
+    description: `Read up to ${MAX_ARCHIVE_FILES} files in one call (same formats as read_document); each comes back under its own heading.`,
+    inputSchema: { paths: z.array(z.string()).min(1).max(MAX_ARCHIVE_FILES), max_chars_each: z.number().int().positive().optional().describe("default 20000") },
+  }, async ({ paths, max_chars_each }) => {
+    const rs = await readDocuments(paths, { maxChars: max_chars_each || 20_000 })
+    return text(rs.map((r) => (r.error ? `# ${path.basename(r.file)}\n\nerror: ${r.error}\n` : header(r) + r.text + "\n")).join("\n---\n\n"))
+  })
+
+  server.registerTool("read_image", {
+    title: "Look at an image",
+    description: "Return an image for the model to see (png, jpg, webp, gif, bmp, tiff, heic, svg, avif). It is EXIF-rotated and resized to fit max_side (default 1568) and sent as PNG/JPEG. Use a vision seat (palette-llm-max or palette-llm-fast).",
+    inputSchema: { path: z.string(), max_side: z.number().int().min(256).max(4096).optional() },
+  }, async ({ path: p, max_side }) => {
+    try {
+      const r = await normalizeImage(p, { maxSide: max_side })
+      return { content: [{ type: "text", text: `${path.basename(p)}: ${r.original.format} ${r.original.width}×${r.original.height} → ${r.width}×${r.height} ${r.mimeType} (${r.data.length} B, decoded via ${r.decodedVia})` }, { type: "image", data: r.data.toString("base64"), mimeType: r.mimeType }] }
+    } catch (e) { return fail(e) }
+  })
+
+  server.registerTool("extract_images", {
+    title: "Extract embedded images",
+    description: "Write the images embedded in a hwp, hwpx, docx, pptx, xlsx or zip to a folder and list them, so they can be viewed with read_image or reused in a new document.",
+    inputSchema: { path: z.string(), out_dir: z.string().optional().describe("default: a temp folder") },
+  }, async ({ path: p, out_dir }) => {
+    try { const r = await extractImages(p, out_dir); return text(`${r.images.length} images in ${r.dir}\n` + r.images.map((i) => `- ${i.path} (${i.bytes} B)`).join("\n")) } catch (e) { return fail(e) }
+  })
+
+  server.registerTool("create_document", {
+    title: "Create a document",
+    description: `Write a real file from markdown (headings, paragraphs, bullets, numbered lists, tables, code). Native: ${NATIVE.join(", ")}. Via LibreOffice when installed: ${Object.keys(VIA_LO).join(", ")}. hwp (binary) is not available: create hwpx, which 한글 opens natively. Korean font defaults to ${DEFAULT_FONT}; HWPX keeps Hancom's default fonts.`,
+    inputSchema: { path: z.string().describe("output file path; the extension picks the format unless format is given"), markdown: z.string(), title: z.string().optional(), format: z.string().optional(), font: z.string().optional().describe("font family for docx/xlsx/pptx/html, e.g. Noto Sans KR") },
+  }, async ({ path: p, markdown, title, format, font }) => {
+    try { const r = await createDocument({ format, out: p, title: title || path.basename(p, path.extname(p)), markdown, font: font || DEFAULT_FONT }); return text(`created ${r.path} (${r.format}, ${r.blocks} blocks${r.via ? `, via ${r.via}` : ""})`) } catch (e) { return fail(e) }
+  })
+
+  server.registerTool("convert_document", {
+    title: "Convert a document",
+    description: "Convert a file to another format (e.g. hwpx → docx, docx → pdf, xlsx → csv, pptx → pdf). LibreOffice is used when it is installed and the pair needs it; otherwise the file is read and rewritten natively.",
+    inputSchema: { path: z.string(), to: z.string().describe("target extension"), out_dir: z.string().optional() },
+  }, async ({ path: p, to, out_dir }) => {
+    try { const r = await convertDocument(p, to, out_dir); return text(`converted → ${r.path} (via ${r.via})`) } catch (e) { return fail(e) }
+  })
+
+  server.registerTool("list_formats", { title: "Supported formats", description: "What can be read and created on this machine.", inputSchema: {} }, async () => text(JSON.stringify(formatsTable(), null, 2)))
+
+  await server.connect(new StdioServerTransport())
+}
+
+async function cli(argv) {
+  const [cmd, ...rest] = argv
+  const flag = (name, dflt) => { const i = rest.indexOf(`--${name}`); return i >= 0 ? rest[i + 1] : dflt }
+  const positional = rest.filter((a, i) => !a.startsWith("--") && (i === 0 || !rest[i - 1].startsWith("--")))
+  switch (cmd) {
+    case "mcp": return mcp()
+    case "read": { const r = await readDocument(positional[0], { maxChars: +flag("max-chars", 5_000_000) }); process.stdout.write(r.text + "\n"); return }
+    case "create": {
+      const out = flag("out") || positional[0]
+      const md = flag("markdown") || (positional[1] && fs.existsSync(positional[1]) ? fs.readFileSync(positional[1], "utf8") : fs.readFileSync(0, "utf8"))
+      const r = await createDocument({ format: flag("format"), out, title: flag("title", path.basename(out, path.extname(out))), markdown: md, font: flag("font", DEFAULT_FONT) })
+      console.log(`created ${r.path}`); return
+    }
+    case "convert": { const r = await convertDocument(positional[0], positional[1], flag("out-dir")); console.log(`converted → ${r.path} (via ${r.via})`); return }
+    case "image": { const r = await normalizeImage(positional[0], { maxSide: +flag("max-side", 1568) }); const out = flag("out") || positional[0].replace(/\.[^.]+$/, "") + (r.mimeType === "image/png" ? ".normalized.png" : ".normalized.jpg"); fs.writeFileSync(out, r.data); console.log(`${out} ${r.width}×${r.height}`); return }
+    case "extract-images": { const r = await extractImages(positional[0], flag("out-dir")); console.log(r.images.map((i) => i.path).join("\n") || "(no images)"); return }
+    case "formats": console.log(JSON.stringify(formatsTable(), null, 2)); return
+    case "version": case "--version": case "-v": console.log(VERSION); return
+    default:
+      console.log(`palette-docs ${VERSION} — documents and images for Palette Code
+
+  palette-docs mcp                                  stdio MCP server (read_document, read_documents, read_image,
+                                                    extract_images, create_document, convert_document, list_formats)
+  palette-docs read <file> [--max-chars N]          hwp hwpx docx doc rtf odt xlsx xls csv pptx ppt pdf html txt md json zip
+  palette-docs create <out> [<markdown.md>] [--title T] [--font F] [--format docx|hwpx|xlsx|pptx|md|csv|html|pdf|doc|xls|ppt|odt]
+  palette-docs convert <file> <to> [--out-dir D]
+  palette-docs image <file> [--max-side N] [--out F] png jpg webp gif bmp tiff heic svg avif → model-ready png/jpg
+  palette-docs extract-images <file> [--out-dir D]
+  palette-docs formats`)
+  }
+}
+
+cli(process.argv.slice(2)).catch((e) => { console.error(e.message); process.exit(1) })

package/src/read.js

@@ -0,0 +1,214 @@
+// Read any office / Korean / PDF / archive input into markdown text the agent can work with.
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { execFileSync } from "node:child_process"
+import JSZip from "jszip"
+import { XMLParser } from "fast-xml-parser"
+import TurndownService from "turndown"
+import { gfm } from "turndown-plugin-gfm"
+import * as XLSX from "xlsx"
+import { hwpRead, hwpxRead } from "./hwp.js"
+import { mdTable } from "./blocks.js"
+
+export const DOC_EXT = ["hwp", "hwpx", "docx", "doc", "rtf", "odt", "xlsx", "xlsm", "xls", "ods", "csv", "tsv", "pptx", "ppt", "odp", "pdf", "txt", "md", "markdown", "json", "html", "htm", "xml", "yaml", "yml"]
+export const IMG_EXT = ["png", "jpg", "jpeg", "webp", "gif", "bmp", "tif", "tiff", "heic", "heif", "svg", "avif"]
+export const ARCHIVE_EXT = ["zip"]
+export const MAX_ARCHIVE_FILES = 20
+
+export const extOf = (p) => path.extname(p).slice(1).toLowerCase()
+
+// ---------- LibreOffice (optional) ----------
+export function soffice() {
+  const candidates = [process.env.PALETTE_DOCS_SOFFICE, "/Applications/LibreOffice.app/Contents/MacOS/soffice", "/opt/homebrew/bin/soffice", "/usr/bin/soffice", "/usr/bin/libreoffice", "C:\\Program Files\\LibreOffice\\program\\soffice.exe"].filter(Boolean)
+  for (const c of candidates) if (fs.existsSync(c)) return c
+  for (const name of ["soffice", "libreoffice"]) {
+    try {
+      const found = execFileSync(process.platform === "win32" ? "where" : "which", [name], { stdio: ["ignore", "pipe", "ignore"] }).toString().trim().split("\n")[0]
+      if (found) return found
+    } catch {}
+  }
+  return null
+}
+
+/** Convert with LibreOffice into `outDir`; returns the produced path. Separate profile so an open LibreOffice does not block it. */
+export function sofficeConvert(src, toExt, outDir) {
+  const bin = soffice()
+  if (!bin) throw new Error(`LibreOffice is needed to handle .${extOf(src)} -> .${toExt} (install from libreoffice.org or brew install --cask libreoffice)`)
+  fs.mkdirSync(outDir, { recursive: true })
+  const profile = path.join(os.tmpdir(), "palette-docs-lo")
+  execFileSync(bin, [`-env:UserInstallation=file://${profile}`, "--headless", "--norestore", "--convert-to", toExt, "--outdir", outDir, src], { stdio: ["ignore", "pipe", "pipe"], timeout: 180_000 })
+  const out = path.join(outDir, path.basename(src, path.extname(src)) + "." + toExt.split(":")[0])
+  if (!fs.existsSync(out)) throw new Error(`LibreOffice did not produce ${out}`)
+  return out
+}
+
+const tmpDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "palette-docs-"))
+
+// ---------- DOCX ----------
+async function readDocx(buffer) {
+  const mammoth = (await import("mammoth")).default
+  const { value: html, messages } = await mammoth.convertToHtml({ buffer })
+  const td = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced", bulletListMarker: "-" })
+  td.use(gfm)
+  const text = td.turndown(html)
+  return { text, meta: { warnings: messages.filter((m) => m.type === "warning").length } }
+}
+
+// ---------- XLSX / CSV ----------
+function readSheet(buffer, { maxRows }, ext = "") {
+  // CSV/TSV are text: decode as UTF-8 (BOM tolerated) so Korean survives; binary workbooks go in as buffers.
+  const wb = ["csv", "tsv", "txt"].includes(ext)
+    ? XLSX.read(buffer.toString("utf8").replace(/^/, ""), { type: "string", cellDates: true, FS: ext === "tsv" ? "\t" : undefined })
+    : XLSX.read(buffer, { type: "buffer", cellDates: true })
+  const parts = []
+  const meta = { sheets: [] }
+  for (const name of wb.SheetNames) {
+    const ws = wb.Sheets[name]
+    const rows = XLSX.utils.sheet_to_json(ws, { header: 1, raw: false, defval: "" })
+    const trimmed = rows.filter((r) => r.some((c) => String(c).trim() !== ""))
+    meta.sheets.push({ name, rows: trimmed.length, truncated: trimmed.length > maxRows })
+    parts.push(`## ${name} (${trimmed.length} rows)`)
+    if (trimmed.length) parts.push(mdTable(trimmed.slice(0, maxRows)))
+    if (trimmed.length > maxRows) parts.push(`… ${trimmed.length - maxRows} more rows not shown`)
+    parts.push("")
+  }
+  return { text: parts.join("\n"), meta }
+}
+
+// ---------- PPTX ----------
+const ooxml = new XMLParser({ preserveOrder: true, ignoreAttributes: true, trimValues: false, parseTagValue: false })
+const tagOf = (n) => Object.keys(n).find((k) => k !== ":@")
+function collect(node, tag, out = []) {
+  const t = tagOf(node)
+  if (t === tag) out.push(node)
+  else if (Array.isArray(node[t])) for (const c of node[t]) collect(c, tag, out)
+  return out
+}
+const textUnder = (node) => {
+  const t = tagOf(node)
+  if (t === "#text") return String(node["#text"])
+  return Array.isArray(node[t]) ? node[t].map(textUnder).join("") : ""
+}
+async function readPptx(buffer) {
+  const zip = await JSZip.loadAsync(buffer)
+  const slides = Object.keys(zip.files).filter((f) => /^ppt\/slides\/slide\d+\.xml$/.test(f)).sort((a, b) => +a.match(/(\d+)\.xml/)[1] - +b.match(/(\d+)\.xml/)[1])
+  const parts = []
+  for (const f of slides) {
+    const n = f.match(/(\d+)\.xml/)[1]
+    const tree = { root: ooxml.parse(await zip.file(f).async("string")) }
+    const lines = []
+    for (const sp of collect(tree, "p:sp")) {
+      const paras = collect(sp, "a:p").map((p) => collect(p, "a:t").map(textUnder).join("")).filter((s) => s.trim())
+      if (paras.length) lines.push(...paras)
+    }
+    for (const tbl of collect(tree, "a:tbl")) {
+      const rows = collect(tbl, "a:tr").map((tr) => collect(tr, "a:tc").map((tc) => collect(tc, "a:p").map((p) => collect(p, "a:t").map(textUnder).join("")).join(" ")))
+      if (rows.length) lines.push("", mdTable(rows), "")
+    }
+    const notes = zip.file(`ppt/notesSlides/notesSlide${n}.xml`)
+    if (notes) {
+      const nt = collect({ root: ooxml.parse(await notes.async("string")) }, "a:t").map(textUnder).join("").trim()
+      if (nt) lines.push("", `> notes: ${nt}`)
+    }
+    parts.push(`## Slide ${n}`, ...lines, "")
+  }
+  return { text: parts.join("\n"), meta: { slides: slides.length } }
+}
+
+// ---------- PDF ----------
+async function readPdf(buffer) {
+  const { PDFParse } = await import("pdf-parse")
+  const p = new PDFParse({ data: new Uint8Array(buffer) })
+  try {
+    const r = await p.getText()
+    return { text: String(r.text || ""), meta: { pages: r.total ?? r.numpages ?? undefined } }
+  } finally {
+    try { await p.destroy() } catch {}
+  }
+}
+
+// ---------- HTML ----------
+function readHtml(buffer) {
+  const td = new TurndownService({ headingStyle: "atx", codeBlockStyle: "fenced" })
+  td.use(gfm)
+  td.remove(["script", "style", "noscript"])
+  return { text: td.turndown(buffer.toString("utf8")), meta: {} }
+}
+
+// ---------- ZIP ----------
+async function readZip(file, opts, depth) {
+  const zip = await JSZip.loadAsync(fs.readFileSync(file))
+  const entries = Object.values(zip.files).filter((e) => !e.dir && !/(^|\/)(__MACOSX|\.)/.test(e.name))
+  const supported = entries.filter((e) => [...DOC_EXT, ...IMG_EXT].includes(extOf(e.name)))
+  const picked = supported.slice(0, MAX_ARCHIVE_FILES)
+  const dir = tmpDir()
+  const parts = [`# ${path.basename(file)} — ${entries.length} files, ${supported.length} readable, ${picked.length} read`]
+  const list = entries.map((e) => `- ${e.name} (${e._data?.uncompressedSize ?? "?"} B)`)
+  parts.push(...list.slice(0, 200), "")
+  const per = Math.max(2000, Math.floor(opts.maxChars / Math.max(1, picked.length)))
+  for (const e of picked) {
+    const out = path.join(dir, e.name.replace(/[\\/]/g, "__"))
+    fs.writeFileSync(out, await e.async("nodebuffer"))
+    try {
+      const r = await readDocument(out, { ...opts, maxChars: per }, depth + 1)
+      parts.push(`## ${e.name}`, r.text, "")
+    } catch (err) {
+      parts.push(`## ${e.name}`, `(could not read: ${err.message})`, "")
+    }
+  }
+  if (supported.length > picked.length) parts.push(`… ${supported.length - picked.length} more readable files not read (limit ${MAX_ARCHIVE_FILES})`)
+  return { text: parts.join("\n"), meta: { files: entries.length, read: picked.length, extracted_to: dir } }
+}
+
+// ---------- dispatcher ----------
+export async function readDocument(file, opts = {}, depth = 0) {
+  const o = { maxChars: 60_000, maxRows: 300, ...opts }
+  if (!fs.existsSync(file)) throw new Error(`no such file: ${file}`)
+  const ext = extOf(file)
+  const stat = fs.statSync(file)
+  let result
+  if (ext === "zip") {
+    if (depth > 0) throw new Error("nested archives are not expanded")
+    result = await readZip(file, o, depth)
+  } else if (IMG_EXT.includes(ext)) {
+    const sharp = (await import("sharp")).default
+    let m = {}
+    try { m = await sharp(file).metadata() } catch {}
+    result = { text: `(image ${ext}${m.width ? ` ${m.width}×${m.height}` : ""}; use read_image to see it)`, meta: { width: m.width, height: m.height } }
+  } else {
+    const buffer = fs.readFileSync(file)
+    switch (ext) {
+      case "hwp": result = hwpRead(buffer); result = { text: result.text, meta: { sections: result.sections, images: result.images.length } }; break
+      case "hwpx": result = await hwpxRead(buffer); result = { text: result.text, meta: { sections: result.sections, images: result.images.length, title: result.title } }; break
+      case "docx": result = await readDocx(buffer); break
+      case "doc": case "rtf": case "odt": case "wps": result = await readDocx(fs.readFileSync(sofficeConvert(file, "docx", tmpDir()))); break
+      case "xlsx": case "xlsm": case "xls": case "ods": case "csv": case "tsv": result = readSheet(buffer, o, ext); break
+      case "pptx": result = await readPptx(buffer); break
+      case "ppt": case "odp": result = await readPptx(fs.readFileSync(sofficeConvert(file, "pptx", tmpDir()))); break
+      case "pdf": result = await readPdf(buffer); break
+      case "html": case "htm": result = readHtml(buffer); break
+      case "txt": case "md": case "markdown": case "json": case "xml": case "yaml": case "yml": result = { text: buffer.toString("utf8"), meta: {} }; break
+      default: throw new Error(`unsupported input .${ext}; supported: ${[...DOC_EXT, ...IMG_EXT, ...ARCHIVE_EXT].join(", ")}`)
+    }
+  }
+  let text = result.text.replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim()
+  const chars = text.length
+  let truncated = false
+  if (chars > o.maxChars) { text = text.slice(0, o.maxChars) + `\n\n… truncated (${chars} chars total; raise max_chars to read more)`; truncated = true }
+  return { file, format: ext, bytes: stat.size, chars, truncated, meta: result.meta || {}, text }
+}
+
+export async function readDocuments(files, opts = {}) {
+  if (files.length > MAX_ARCHIVE_FILES) throw new Error(`at most ${MAX_ARCHIVE_FILES} files per call (got ${files.length})`)
+  const out = []
+  for (const f of files) {
+    try { out.push(await readDocument(f, opts)) } catch (e) { out.push({ file: f, error: e.message }) }
+  }
+  return out
+}
+
+export const formatsTable = () => ({
+  read: { documents: DOC_EXT, images: IMG_EXT, archives: ARCHIVE_EXT, max_files_per_call: MAX_ARCHIVE_FILES, libreoffice: !!soffice() },
+  create: { native: ["docx", "hwpx", "xlsx", "pptx", "md", "txt", "csv", "html"], via_libreoffice: ["pdf", "doc", "xls", "ppt", "odt", "ods", "odp", "rtf"], not_available: ["hwp (binary 5.0 export needs 한글 or a LibreOffice H2Orestart build; create hwpx instead)"] },
+})

package/src/write.js

@@ -0,0 +1,320 @@
+// Create real office files from markdown: DOCX, HWPX (한글), XLSX, PPTX natively; PDF/DOC/XLS/PPT/ODF via LibreOffice.
+// DOCX/HWPX/XLSX writers ported from Palette Island ui/export.js (same owner). HWPX starts from Hancom's own blank
+// template (vendor/hwpx/blank.hwpx, from hwpxlib, Apache-2.0) so 한글 opens it as a native document.
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import JSZip from "jszip"
+import { blocksOf, esc, plain, today, numCols, marker, toMarkdown } from "./blocks.js"
+import { sofficeConvert } from "./read.js"
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+export const DEFAULT_FONT = "Malgun Gothic" // 맑은 고딕: the Korean office default; Word/Excel substitute on Mac
+const FONT_KO = { "Malgun Gothic": "맑은 고딕", "Noto Sans KR": "Noto Sans KR", "Apple SD Gothic Neo": "Apple SD Gothic Neo", "Nanum Gothic": "나눔고딕", "Palette Noto Sans KR": "Palette Noto Sans KR" }
+
+// ---------- DOCX ----------
+export async function toDocx(blocks, title, { font = DEFAULT_FONT } = {}) {
+  const zip = new JSZip()
+  const W = 'xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"'
+  const run = (t, { b = false, color = "", sz = 0, mono = false } = {}) => `<w:r><w:rPr>${mono ? '<w:rFonts w:ascii="Menlo" w:hAnsi="Menlo" w:cs="Menlo"/>' : ""}${b ? "<w:b/>" : ""}${color ? `<w:color w:val="${color}"/>` : ""}${sz ? `<w:sz w:val="${sz}"/>` : ""}</w:rPr><w:t xml:space="preserve">${esc(t)}</w:t></w:r>`
+  const para = (t, style = "", extra = "", ro = {}) => `<w:p><w:pPr>${style ? `<w:pStyle w:val="${style}"/>` : ""}${extra}</w:pPr>${run(t, ro)}</w:p>`
+  const docTitle = (blocks.find((k) => k.type === "h" && k.level === 1) || {}).text || title
+  const body = [para(docTitle, "Title"), para(`${today()} · Palette`, "Subtitle")]
+  for (const k of blocks) {
+    if (k.type === "h" && k.level === 1 && k.text === docTitle) continue
+    if (k.type === "h") body.push(para(k.text, k.level <= 2 ? "Heading1" : "Heading2"))
+    else if (k.type === "li") body.push(para(marker(k) + "\t" + k.text, "ListBullet"))
+    else if (k.type === "p") body.push(para(k.text))
+    else if (k.type === "code") for (const line of k.text.split("\n")) body.push(para(line, "Code", "", { mono: true, sz: 18 }))
+    else if (k.type === "table") {
+      const cols = Math.max(...k.rows.map((r) => r.length))
+      const nc = numCols(k.rows)
+      const TW = 9506 // A4 text width in twips (11906 minus 1200 margins either side)
+      const len = Array.from({ length: cols }, (_, c) => Math.min(30, Math.max(4, ...k.rows.map((r) => [...String(r[c] ?? "")].reduce((a, ch) => a + (/[가-힣]/.test(ch) ? 2 : 1), 0)))))
+      const tot = len.reduce((a, b) => a + b, 0)
+      const gw = len.map((x) => Math.floor((TW * x) / tot))
+      gw[cols - 1] += TW - gw.reduce((a, b) => a + b, 0)
+      const line = (x) => `<w:${x} w:val="single" w:sz="4" w:color="D9D4CC"/>`
+      const bd = `<w:tblBorders>${line("top")}<w:left w:val="nil"/>${line("bottom")}<w:right w:val="nil"/>${line("insideH")}<w:insideV w:val="nil"/></w:tblBorders>`
+      body.push(
+        `<w:tbl><w:tblPr><w:tblW w:w="${TW}" w:type="dxa"/>${bd}<w:tblLayout w:type="fixed"/><w:tblCellMar><w:top w:w="80" w:type="dxa"/><w:left w:w="120" w:type="dxa"/><w:bottom w:w="80" w:type="dxa"/><w:right w:w="120" w:type="dxa"/></w:tblCellMar></w:tblPr><w:tblGrid>${gw.map((x) => `<w:gridCol w:w="${x}"/>`).join("")}</w:tblGrid>` +
+          k.rows
+            .map(
+              (r, ri) =>
+                `<w:tr>${ri === 0 ? "<w:trPr><w:tblHeader/></w:trPr>" : ""}` +
+                Array.from({ length: cols }, (_, ci) => r[ci] ?? "")
+                  .map((c, ci) => {
+                    const fill = ri === 0 ? "1A1A1A" : ri % 2 === 0 ? "F5F3EF" : "FFFFFF"
+                    const jc = nc[ci] ? '<w:jc w:val="right"/>' : ""
+                    return `<w:tc><w:tcPr><w:tcW w:w="${gw[ci]}" w:type="dxa"/><w:shd w:val="clear" w:color="auto" w:fill="${fill}"/><w:vAlign w:val="center"/></w:tcPr><w:p><w:pPr><w:spacing w:before="0" w:after="0"/>${jc}</w:pPr>${run(c, { b: ri === 0, color: ri === 0 ? "FFFFFF" : "", sz: 19 })}</w:p></w:tc>`
+                  })
+                  .join("") +
+                "</w:tr>",
+            )
+            .join("") +
+          "</w:tbl>",
+      )
+      body.push('<w:p><w:pPr><w:spacing w:after="120"/></w:pPr></w:p>')
+    }
+  }
+  const ea = FONT_KO[font] || font
+  const styles = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:styles ${W}>
+<w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:ascii="${esc(font)}" w:hAnsi="${esc(font)}" w:eastAsia="${esc(ea)}" w:cs="${esc(font)}"/><w:sz w:val="21"/><w:color w:val="1A1A1A"/><w:lang w:eastAsia="ko-KR"/></w:rPr></w:rPrDefault><w:pPrDefault><w:pPr><w:spacing w:after="120" w:line="300" w:lineRule="auto"/></w:pPr></w:pPrDefault></w:docDefaults>
+<w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>
+<w:style w:type="paragraph" w:styleId="Title"><w:name w:val="Title"/><w:basedOn w:val="Normal"/><w:pPr><w:spacing w:after="60"/></w:pPr><w:rPr><w:b/><w:sz w:val="44"/><w:color w:val="000000"/></w:rPr></w:style>
+<w:style w:type="paragraph" w:styleId="Subtitle"><w:name w:val="Subtitle"/><w:basedOn w:val="Normal"/><w:pPr><w:pBdr><w:bottom w:val="single" w:sz="12" w:space="8" w:color="000000"/></w:pBdr><w:spacing w:after="360"/></w:pPr><w:rPr><w:sz w:val="18"/><w:color w:val="8A8A8A"/></w:rPr></w:style>
+<w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:pPr><w:keepNext/><w:spacing w:before="320" w:after="120"/><w:outlineLvl w:val="0"/></w:pPr><w:rPr><w:b/><w:sz w:val="30"/><w:color w:val="000000"/></w:rPr></w:style>
+<w:style w:type="paragraph" w:styleId="Heading2"><w:name w:val="heading 2"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:pPr><w:keepNext/><w:spacing w:before="220" w:after="80"/><w:outlineLvl w:val="1"/></w:pPr><w:rPr><w:b/><w:sz w:val="24"/><w:color w:val="333333"/></w:rPr></w:style>
+<w:style w:type="paragraph" w:styleId="ListBullet"><w:name w:val="List Bullet"/><w:basedOn w:val="Normal"/><w:pPr><w:tabs><w:tab w:val="left" w:pos="360"/></w:tabs><w:spacing w:after="60"/><w:ind w:left="360" w:hanging="360"/></w:pPr></w:style>
+<w:style w:type="paragraph" w:styleId="Code"><w:name w:val="Code"/><w:basedOn w:val="Normal"/><w:pPr><w:shd w:val="clear" w:color="auto" w:fill="F5F3EF"/><w:spacing w:after="0" w:line="260" w:lineRule="auto"/></w:pPr></w:style>
+<w:style w:type="paragraph" w:styleId="Footer"><w:name w:val="footer"/><w:basedOn w:val="Normal"/><w:rPr><w:sz w:val="16"/><w:color w:val="8A8A8A"/></w:rPr></w:style>
+</w:styles>`
+  const footer = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:ftr ${W}><w:p><w:pPr><w:pStyle w:val="Footer"/><w:jc w:val="right"/></w:pPr>${run(docTitle.slice(0, 60) + "  ·  Palette  ·  ")}<w:fldSimple w:instr="PAGE"><w:r><w:t>1</w:t></w:r></w:fldSimple></w:p></w:ftr>`
+  zip.file("[Content_Types].xml", '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><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="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/><Override PartName="/word/footer1.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"/></Types>')
+  zip.file("_rels/.rels", '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>')
+  zip.file("word/_rels/document.xml.rels", '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rIdS" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/><Relationship Id="rIdF" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer" Target="footer1.xml"/></Relationships>')
+  zip.file("word/styles.xml", styles)
+  zip.file("word/footer1.xml", footer)
+  zip.file("word/document.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document ${W}><w:body>${body.join("")}<w:sectPr><w:footerReference w:type="default" r:id="rIdF"/><w:pgSz w:w="11906" w:h="16838"/><w:pgMar w:top="1300" w:right="1200" w:bottom="1300" w:left="1200" w:header="700" w:footer="600" w:gutter="0"/></w:sectPr></w:body></w:document>`)
+  return zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" })
+}
+
+// ---------- HWPX ----------
+export async function toHwpx(blocks, title) {
+  const zip = await JSZip.loadAsync(fs.readFileSync(path.join(here, "..", "vendor", "hwpx", "blank.hwpx")))
+  const secPath = "Contents/section0.xml"
+  const sec = await zip.file(secPath).async("string")
+  zip.file("Contents/header.xml", hwpxHeader(await zip.file("Contents/header.xml").async("string")))
+  // Hancom blank + hwpxHeader: charPr 0 = 10pt body, 7 = 10pt bold, 8 = 16pt bold (title), 9 = 13pt bold, 10 = 11pt bold;
+  // paraPr 3 = justified body, 16/17/18 = left/right/centre (table cells), 19 = heading (space before/after)
+  let id = 1000
+  const run = (t, char) => `<hp:run charPrIDRef="${char}"><hp:t>${esc(t)}</hp:t></hp:run>`
+  const p = (t, { char = 0, para = 3 } = {}) => `<hp:p id="${id++}" paraPrIDRef="${para}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0">${run(t, char)}</hp:p>`
+  const paras = [p(title, { char: 8, para: 19 })]
+  for (const k of blocks) {
+    if (k.type === "h") paras.push(p(k.text, { char: k.level <= 1 ? 8 : k.level === 2 ? 9 : 10, para: 19 }))
+    else if (k.type === "li") paras.push(p(marker(k) + " " + k.text))
+    else if (k.type === "p") paras.push(p(k.text))
+    else if (k.type === "code") for (const line of k.text.split("\n")) paras.push(p(line))
+    else if (k.type === "table") { paras.push(hwpxTable(k.rows, () => id++)); paras.push(p("")) }
+  }
+  const out = sec.replace(/<\/hs:sec>\s*$/, paras.join("") + "</hs:sec>")
+  zip.file(secPath, out)
+  const hpf = await zip.file("Contents/content.hpf").async("string")
+  zip.file("Contents/content.hpf", hpf.replace(/<opf:title>[^<]*<\/opf:title>|<opf:title\/>/, `<opf:title>${esc(title)}</opf:title>`))
+  // mimetype must stay first and uncompressed (OCF rule) — JSZip keeps insertion order of the loaded archive
+  zip.file("mimetype", "application/hwp+zip", { compression: "STORE" })
+  return zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE", mimeType: "application/hwp+zip" })
+}
+
+/** Adds what tables and headings need to Hancom's blank header, in Hancom's own markup (copied from a 한글-saved
+ *  table, hwpxlib testFile/reader_writer/SimpleTable.hwpx): borderFill 3 = 0.12 mm solid grid, 4 = the same with a
+ *  shaded header fill; charPr 7-10 = bold sizes; paraPr 16-19 = cell left/right/centre and heading spacing. */
+function hwpxHeader(h) {
+  const bump = (tag, n) => { h = h.replace(new RegExp(`<hh:${tag} itemCnt="(\\d+)"`), (m, c) => `<hh:${tag} itemCnt="${+c + n}"`) }
+  const side = (k) => `<hh:${k}Border type="SOLID" width="0.12 mm" color="#000000"/>`
+  const bf = (bid, fill) => `<hh:borderFill id="${bid}" threeD="0" shadow="0" centerLine="NONE" breakCellSeparateLine="0"><hh:slash type="NONE" Crooked="0" isCounter="0"/><hh:backSlash type="NONE" Crooked="0" isCounter="0"/>${["left", "right", "top", "bottom"].map(side).join("")}<hh:diagonal type="SOLID" width="0.1 mm" color="#000000"/>${fill ? `<hc:fillBrush><hc:winBrush faceColor="${fill}" hatchColor="#FF000000" alpha="0"/></hc:fillBrush>` : ""}</hh:borderFill>`
+  h = h.replace("</hh:borderFills>", bf(3) + bf(4, "#E8EEF6") + "</hh:borderFills>"); bump("borderFills", 2)
+  const c0 = h.match(/<hh:charPr id="0"[\s\S]*?<\/hh:charPr>/)[0]
+  const bold = (cid, ht) => c0.replace('id="0"', `id="${cid}"`).replace(/height="\d+"/, `height="${ht}"`).replace("<hh:underline", "<hh:bold/><hh:underline")
+  h = h.replace("</hh:charProperties>", bold(7, 1000) + bold(8, 1600) + bold(9, 1300) + bold(10, 1100) + "</hh:charProperties>"); bump("charProperties", 4)
+  const p3 = h.match(/<hh:paraPr id="3"[\s\S]*?<\/hh:paraPr>/)[0]
+  const para = (pid, align, prev = 0, next = 0) => p3.replace('id="3"', `id="${pid}"`).replace(/horizontal="\w+"/, `horizontal="${align}"`)
+    .replace(/<hc:prev value="0"/g, `<hc:prev value="${prev}"`).replace(/<hc:next value="0"/g, `<hc:next value="${next}"`)
+    .replace(/lineSpacing type="PERCENT" value="160"/g, `lineSpacing type="PERCENT" value="${pid === 19 ? 160 : 130}"`)
+  h = h.replace("</hh:paraProperties>", para(16, "LEFT") + para(17, "RIGHT") + para(18, "CENTER") + para(19, "LEFT", 1200, 400) + "</hh:paraProperties>"); bump("paraProperties", 4)
+  return h
+}
+
+/** A real 한글 table: full text width, header row shaded, bold and repeated on every page, numeric columns right-aligned. */
+function hwpxTable(rows, nextId) {
+  const W = 42520 // A4 text width in HWPUNIT (59528 minus 8504 margins either side)
+  const n = Math.max(...rows.map((r) => r.length))
+  const body = rows.map((r) => Array.from({ length: n }, (_, i) => r[i] ?? ""))
+  const nc = numCols(body)
+  const len = Array.from({ length: n }, (_, c) => Math.min(30, Math.max(4, ...body.map((r) => [...String(r[c])].reduce((a, ch) => a + (/[가-힣]/.test(ch) ? 2 : 1), 0)))))
+  const tot = len.reduce((a, b) => a + b, 0)
+  const w = len.map((x) => Math.floor((W * x) / tot))
+  w[n - 1] += W - w.reduce((a, b) => a + b, 0)
+  const H = 2000
+  const cell = (txt, r, c) => {
+    const head = r === 0
+    const para = head ? 18 : nc[c] ? 17 : 16
+    return `<hp:tc name="" header="${head ? 1 : 0}" hasMargin="0" protect="0" editable="0" dirty="0" borderFillIDRef="${head ? 4 : 3}"><hp:subList id="" textDirection="HORIZONTAL" lineWrap="BREAK" vertAlign="CENTER" linkListIDRef="0" linkListNextIDRef="0" textWidth="0" textHeight="0" hasTextRef="0" hasNumRef="0"><hp:p id="0" paraPrIDRef="${para}" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="${head ? 7 : 0}"><hp:t>${esc(plain(String(txt)))}</hp:t></hp:run></hp:p></hp:subList><hp:cellAddr colAddr="${c}" rowAddr="${r}"/><hp:cellSpan colSpan="1" rowSpan="1"/><hp:cellSz width="${w[c]}" height="${H}"/><hp:cellMargin left="510" right="510" top="141" bottom="141"/></hp:tc>`
+  }
+  const trs = body.map((r, ri) => `<hp:tr>${r.map((x, ci) => cell(x, ri, ci)).join("")}</hp:tr>`).join("")
+  const tbl = `<hp:tbl id="${1900000000 + nextId()}" zOrder="0" numberingType="TABLE" textWrap="TOP_AND_BOTTOM" textFlow="BOTH_SIDES" lock="0" dropcapstyle="None" pageBreak="CELL" repeatHeader="1" rowCnt="${body.length}" colCnt="${n}" cellSpacing="0" borderFillIDRef="3" noAdjust="0"><hp:sz width="${W}" widthRelTo="ABSOLUTE" height="${H * body.length}" heightRelTo="ABSOLUTE" protect="0"/><hp:pos treatAsChar="0" affectLSpacing="0" flowWithText="1" allowOverlap="0" holdAnchorAndSO="0" vertRelTo="PARA" horzRelTo="COLUMN" vertAlign="TOP" horzAlign="LEFT" vertOffset="0" horzOffset="0"/><hp:outMargin left="0" right="0" top="283" bottom="283"/><hp:inMargin left="510" right="510" top="141" bottom="141"/>${trs}</hp:tbl>`
+  return `<hp:p id="${nextId()}" paraPrIDRef="3" styleIDRef="0" pageBreak="0" columnBreak="0" merged="0"><hp:run charPrIDRef="0">${tbl}<hp:t/></hp:run></hp:p>`
+}
+
+// ---------- XLSX ----------
+export async function toXlsx(blocks, title, { font = DEFAULT_FONT } = {}) {
+  const zip = new JSZip()
+  const sheets = []
+  let lastHead = ""
+  for (const k of blocks) {
+    if (k.type === "h") lastHead = k.text
+    if (k.type === "table") sheets.push({ name: lastHead, rows: k.rows })
+  }
+  const prose = blocks.filter((k) => ["h", "p", "li"].includes(k.type) && k.text).map((k) => [k.type === "li" ? `${marker(k)} ${k.text}` : k.text])
+  if (!sheets.length) sheets.push({ name: title, rows: [["내용"], ...prose], text: true })
+  else if (prose.length > 1) sheets.push({ name: "내용", rows: [["내용"], ...prose], text: true })
+  const docTitle = (blocks.find((k) => k.type === "h" && k.level === 1) || {}).text || title
+  const used = new Set()
+  const sheetName = (n, i) => { let x = String(n || `표${i + 1}`).replace(/[\[\]:*?/\\]/g, " ").trim().slice(0, 28) || `표${i + 1}`; while (used.has(x)) x = x.slice(0, 25) + "_" + (i + 1); used.add(x); return x }
+  const col = (n) => { let s = ""; n++; while (n) { const m = (n - 1) % 26; s = String.fromCharCode(65 + m) + s; n = Math.floor((n - 1) / 26) } return s }
+  const cw = (v) => [...String(v)].reduce((a, ch) => a + (/[ᄀ-ￜ]/.test(ch) ? 2 : 1), 0)
+  const numOf = (v) => { const t = String(v).trim().replace(/[,₩\s]/g, "").replace(/^\+/, ""); return /^-?\d+(\.\d+)?$/.test(t) ? t : null }
+  const pctOf = (v) => { const m = String(v).trim().replace(/\s/g, "").match(/^([+-]?\d+(?:\.\d+)?)%$/); return m ? String(+(parseFloat(m[1]) / 100).toFixed(8)) : null }
+  sheets.forEach((sh, i) => {
+    const rows = sh.rows
+    const cols = Math.max(...rows.map((r) => r.length))
+    const head = 3
+    const widths = Array.from({ length: cols }, (_, c) => Math.min(60, Math.max(9, ...rows.map((r) => cw(r[c] ?? "") + 3))))
+    const xml = []
+    xml.push(`<row r="1" ht="26" customHeight="1"><c r="A1" t="inlineStr" s="2"><is><t>${esc(i === 0 ? docTitle : sh.name || docTitle)}</t></is></c></row>`)
+    xml.push(`<row r="2"><c r="A2" t="inlineStr" s="9"><is><t>${esc(today() + " · Palette")}</t></is></c></row>`)
+    rows.forEach((r, ri) => {
+      const R = head + ri
+      const band = ri > 0 && ri % 2 === 0
+      xml.push(`<row r="${R}"${ri === 0 ? ' ht="22" customHeight="1"' : ""}>` + Array.from({ length: cols }, (_, ci) => {
+        const v = r[ci] ?? ""
+        const ref = col(ci) + R
+        if (ri === 0) return `<c r="${ref}" t="inlineStr" s="1"><is><t>${esc(v)}</t></is></c>`
+        const pc = sh.text ? null : pctOf(v)
+        if (pc !== null) return `<c r="${ref}" s="${band ? 11 : 10}"><v>${pc}</v></c>`
+        const n = sh.text ? null : numOf(v)
+        if (n !== null) return `<c r="${ref}" s="${(n.includes(".") ? 5 : 4) + (band ? 3 : 0)}"><v>${n}</v></c>`
+        return `<c r="${ref}" t="inlineStr" s="${band ? 6 : 3}"><is><t>${esc(v)}</t></is></c>`
+      }).join("") + "</row>")
+    })
+    const last = col(cols - 1) + (head + rows.length - 1)
+    zip.file(`xl/worksheets/sheet${i + 1}.xml`, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetViews><sheetView workbookViewId="0" showGridLines="0"><pane ySplit="${head}" topLeftCell="A${head + 1}" activePane="bottomLeft" state="frozen"/></sheetView></sheetViews><sheetFormatPr defaultRowHeight="18"/><cols>${widths.map((w, c) => `<col min="${c + 1}" max="${c + 1}" width="${w}" customWidth="1"/>`).join("")}</cols><sheetData>${xml.join("")}</sheetData>${rows.length > 1 && !sh.text ? `<autoFilter ref="A${head}:${last}"/>` : ""}<pageMargins left="0.5" right="0.5" top="0.6" bottom="0.6" header="0.3" footer="0.3"/><pageSetup orientation="landscape" fitToWidth="1" fitToHeight="0"/></worksheet>`)
+    sh.title = sheetName(sh.name, i)
+  })
+  zip.file("xl/workbook.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets>${sheets.map((sh, i) => `<sheet name="${esc(sh.title)}" sheetId="${i + 1}" r:id="rId${i + 1}"/>`).join("")}</sheets>${(() => { const d = sheets.map((sh, i) => sh.rows.length > 1 && !sh.text ? `<definedName name="_xlnm._FilterDatabase" localSheetId="${i}" hidden="1">'${esc(sh.title.replace(/'/g, "''"))}'!$A$3:$${col(Math.max(...sh.rows.map((r) => r.length)) - 1)}$${3 + sh.rows.length - 1}</definedName>` : "").join(""); return d ? `<definedNames>${d}</definedNames>` : "" })()}</workbook>`)
+  const F = `<name val="${esc(font)}"/><family val="2"/>`
+  zip.file("xl/styles.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+<numFmts count="3"><numFmt numFmtId="164" formatCode="#,##0"/><numFmt numFmtId="165" formatCode="#,##0.0#"/><numFmt numFmtId="166" formatCode="+0.0%;-0.0%;0.0%"/></numFmts>
+<fonts count="4"><font><sz val="10.5"/><color rgb="FF1A1A1A"/>${F}</font><font><b/><sz val="10.5"/><color rgb="FFFFFFFF"/>${F}</font><font><b/><sz val="15"/><color rgb="FF000000"/>${F}</font><font><sz val="9"/><color rgb="FF8A8A8A"/>${F}</font></fonts>
+<fills count="4"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill><fill><patternFill patternType="solid"><fgColor rgb="FF1A1A1A"/></patternFill></fill><fill><patternFill patternType="solid"><fgColor rgb="FFF5F3EF"/></patternFill></fill></fills>
+<borders count="2"><border/><border><bottom style="thin"><color rgb="FFD9D4CC"/></bottom></border></borders>
+<cellStyleXfs count="1"><xf/></cellStyleXfs>
+<cellXfs count="12">
+<xf fontId="0"/>
+<xf fontId="1" fillId="2" borderId="1" applyFont="1" applyFill="1" applyAlignment="1"><alignment horizontal="center" vertical="center" wrapText="1"/></xf>
+<xf fontId="2" applyFont="1"/>
+<xf fontId="0" borderId="1" applyBorder="1" applyAlignment="1"><alignment vertical="center" wrapText="1"/></xf>
+<xf fontId="0" borderId="1" numFmtId="164" applyNumberFormat="1" applyBorder="1" applyAlignment="1"><alignment vertical="center"/></xf>
+<xf fontId="0" borderId="1" numFmtId="165" applyNumberFormat="1" applyBorder="1" applyAlignment="1"><alignment vertical="center"/></xf>
+<xf fontId="0" fillId="3" borderId="1" applyFill="1" applyBorder="1" applyAlignment="1"><alignment vertical="center" wrapText="1"/></xf>
+<xf fontId="0" fillId="3" borderId="1" numFmtId="164" applyNumberFormat="1" applyFill="1" applyBorder="1" applyAlignment="1"><alignment vertical="center"/></xf>
+<xf fontId="0" fillId="3" borderId="1" numFmtId="165" applyNumberFormat="1" applyFill="1" applyBorder="1" applyAlignment="1"><alignment vertical="center"/></xf>
+<xf fontId="3" applyFont="1"/>
+<xf fontId="0" borderId="1" numFmtId="166" applyNumberFormat="1" applyBorder="1" applyAlignment="1"><alignment vertical="center"/></xf>
+<xf fontId="0" fillId="3" borderId="1" numFmtId="166" applyNumberFormat="1" applyFill="1" applyBorder="1" applyAlignment="1"><alignment vertical="center"/></xf>
+</cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles></styleSheet>`)
+  zip.file("xl/_rels/workbook.xml.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${sheets.map((_, i) => `<Relationship Id="rId${i + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${i + 1}.xml"/>`).join("")}<Relationship Id="rIdS" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/></Relationships>`)
+  zip.file("_rels/.rels", '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>')
+  zip.file("[Content_Types].xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><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/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>${sheets.map((_, i) => `<Override PartName="/xl/worksheets/sheet${i + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`).join("")}</Types>`)
+  return zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" })
+}
+
+// ---------- PPTX ----------
+export async function toPptx(blocks, title, outPath, { font = DEFAULT_FONT } = {}) {
+  const pptxgen = (await import("pptxgenjs")).default
+  const pres = new pptxgen()
+  pres.layout = "LAYOUT_16x9"
+  pres.theme = { headFontFace: font, bodyFontFace: font }
+  const INK = "101516", MUTE = "7B8381", ACC = "006F9C", BG = "F1F0ED"
+  const docTitle = (blocks.find((k) => k.type === "h" && k.level === 1) || {}).text || title
+  const cover = pres.addSlide()
+  cover.background = { color: BG }
+  cover.addText(docTitle, { x: 0.6, y: 1.6, w: 8.8, h: 1.6, fontSize: 34, bold: true, color: INK, fontFace: font, isTextBox: true })
+  cover.addText(`${today()} · Palette`, { x: 0.6, y: 3.3, w: 8.8, h: 0.5, fontSize: 14, color: MUTE, fontFace: font, isTextBox: true })
+  // one slide per heading; the body is bullets + tables
+  const sections = []
+  let cur = null
+  for (const k of blocks) {
+    if (k.type === "h" && k.level <= 2) { if (k.level === 1 && k.text === docTitle && !cur) continue; cur = { title: k.text, items: [] }; sections.push(cur); continue }
+    if (!cur) { cur = { title: docTitle, items: [] }; sections.push(cur) }
+    cur.items.push(k)
+  }
+  for (const s of sections) {
+    const bullets = s.items.filter((k) => ["p", "li", "h", "code"].includes(k.type)).map((k) => ({ text: k.text.length > 160 ? k.text.slice(0, 157) + "…" : k.text, options: { bullet: k.type === "li" ? true : false, breakLine: true, bold: k.type === "h" } }))
+    const tables = s.items.filter((k) => k.type === "table")
+    const chunks = []
+    for (let i = 0; i < bullets.length; i += 7) chunks.push(bullets.slice(i, i + 7))
+    if (!chunks.length && !tables.length) chunks.push([])
+    chunks.forEach((chunk, ci) => {
+      const sl = pres.addSlide()
+      sl.background = { color: "FFFFFF" }
+      sl.addShape(pres.ShapeType.rect, { x: 0, y: 0, w: 0.12, h: 5.625, fill: { color: ACC } })
+      sl.addText(s.title + (chunks.length > 1 ? ` (${ci + 1}/${chunks.length})` : ""), { x: 0.5, y: 0.3, w: 9, h: 0.8, fontSize: 24, bold: true, color: INK, fontFace: font, isTextBox: true })
+      if (chunk.length) sl.addText(chunk.map((b) => ({ ...b, options: { ...b.options, fontSize: 16, color: INK, fontFace: font, paraSpaceAfter: 6 } })), { x: 0.5, y: 1.2, w: 9, h: 4, valign: "top", isTextBox: true })
+    })
+    for (const t of tables) {
+      const sl = pres.addSlide()
+      sl.background = { color: "FFFFFF" }
+      sl.addShape(pres.ShapeType.rect, { x: 0, y: 0, w: 0.12, h: 5.625, fill: { color: ACC } })
+      sl.addText(s.title, { x: 0.5, y: 0.3, w: 9, h: 0.8, fontSize: 24, bold: true, color: INK, fontFace: font, isTextBox: true })
+      const rows = t.rows.slice(0, 14).map((r, ri) => r.map((c) => ({ text: String(c), options: { bold: ri === 0, color: ri === 0 ? "FFFFFF" : INK, fill: { color: ri === 0 ? "1A1A1A" : ri % 2 === 0 ? "F5F3EF" : "FFFFFF" }, fontSize: 11, fontFace: font } })))
+      sl.addTable(rows, { x: 0.5, y: 1.2, w: 9, border: { type: "solid", pt: 0.5, color: "D9D4CC" }, autoPage: false })
+    }
+  }
+  await pres.writeFile({ fileName: outPath })
+  return outPath
+}
+
+// ---------- entry ----------
+export const NATIVE = ["docx", "hwpx", "xlsx", "pptx", "md", "txt", "csv", "html"]
+export const VIA_LO = { pdf: "docx", doc: "docx", odt: "docx", rtf: "docx", xls: "xlsx", ods: "xlsx", ppt: "pptx", odp: "pptx" }
+
+export async function createDocument({ format, out, title = "문서", markdown = "", font = DEFAULT_FONT }) {
+  const fmt = String(format || path.extname(out).slice(1)).toLowerCase()
+  const blocks = blocksOf(markdown)
+  fs.mkdirSync(path.dirname(path.resolve(out)), { recursive: true })
+  const write = async (f, target) => {
+    if (f === "docx") fs.writeFileSync(target, await toDocx(blocks, title, { font }))
+    else if (f === "hwpx") fs.writeFileSync(target, await toHwpx(blocks, title))
+    else if (f === "xlsx") fs.writeFileSync(target, await toXlsx(blocks, title, { font }))
+    else if (f === "pptx") await toPptx(blocks, title, target, { font })
+    else if (f === "md" || f === "txt") fs.writeFileSync(target, toMarkdown(blocks))
+    else if (f === "csv") { const t = blocks.find((k) => k.type === "table"); if (!t) throw new Error("csv needs at least one markdown table"); fs.writeFileSync(target, t.rows.map((r) => r.map((c) => /[",\n]/.test(c) ? `"${c.replace(/"/g, '""')}"` : c).join(",")).join("\n") + "\n") }
+    else if (f === "html") fs.writeFileSync(target, htmlOf(blocks, title, font))
+    else throw new Error(`unsupported format ${f}`)
+  }
+  if (NATIVE.includes(fmt)) { await write(fmt, out); return { path: out, format: fmt, blocks: blocks.length } }
+  if (VIA_LO[fmt]) {
+    if (fmt === "hwp") throw new Error("hwp export is not available; create hwpx")
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "palette-docs-"))
+    const src = path.join(tmp, path.basename(out, path.extname(out)) + "." + VIA_LO[fmt])
+    await write(VIA_LO[fmt], src)
+    const produced = sofficeConvert(src, fmt, tmp)
+    fs.copyFileSync(produced, out)
+    return { path: out, format: fmt, blocks: blocks.length, via: "libreoffice" }
+  }
+  if (fmt === "hwp") throw new Error("hwp (binary 5.0) export needs 한글 or a LibreOffice H2Orestart build; create hwpx instead — 한글 opens it natively")
+  throw new Error(`unsupported output .${fmt}; native: ${NATIVE.join(", ")}; via LibreOffice: ${Object.keys(VIA_LO).join(", ")}`)
+}
+
+function htmlOf(blocks, title, font) {
+  const b = blocks.map((k) => k.type === "h" ? `<h${k.level}>${esc(k.text)}</h${k.level}>` : k.type === "li" ? `<li>${esc(k.text)}</li>` : k.type === "code" ? `<pre><code>${esc(k.text)}</code></pre>` : k.type === "table" ? `<table>${k.rows.map((r, i) => `<tr>${r.map((c) => (i ? `<td>${esc(c)}</td>` : `<th>${esc(c)}</th>`)).join("")}</tr>`).join("")}</table>` : `<p>${esc(k.text)}</p>`).join("\n").replace(/(<li>[\s\S]*?<\/li>\n?)+/g, (m) => `<ul>\n${m}</ul>\n`)
+  return `<!doctype html><html lang="ko"><head><meta charset="utf-8"><title>${esc(title)}</title><style>body{font-family:"${esc(font)}","Apple SD Gothic Neo","Noto Sans KR",sans-serif;max-width:800px;margin:40px auto;padding:0 20px;line-height:1.6;color:#1a1a1a}table{border-collapse:collapse;width:100%}th,td{border-bottom:1px solid #d9d4cc;padding:6px 10px;text-align:left}th{background:#1a1a1a;color:#fff}pre{background:#f5f3ef;padding:12px;overflow:auto}</style></head><body>\n${b}\n</body></html>\n`
+}
+
+/** Convert an existing file to another format: native read + create for text-like targets, LibreOffice otherwise. */
+export async function convertDocument(src, to, outDir) {
+  const { readDocument } = await import("./read.js")
+  const fmt = String(to).toLowerCase()
+  const dir = outDir || path.dirname(path.resolve(src))
+  const out = path.join(dir, path.basename(src, path.extname(src)) + "." + fmt)
+  const ext = path.extname(src).slice(1).toLowerCase()
+  const loDirect = !["hwp", "hwpx"].includes(ext) && (VIA_LO[fmt] || ["docx", "xlsx", "pptx", "html"].includes(fmt))
+  if (loDirect) {
+    try { const produced = sofficeConvert(src, fmt, dir); if (produced !== out) fs.renameSync(produced, out); return { path: out, via: "libreoffice" } } catch (e) { if (!NATIVE.includes(fmt)) throw e }
+  }
+  const r = await readDocument(src, { maxChars: 5_000_000 })
+  return { ...(await createDocument({ format: fmt, out, title: r.meta?.title || path.basename(src, path.extname(src)), markdown: r.text })), via: "palette-docs" }
+}

package/vendor/hwpx/NOTICE.txt

@@ -0,0 +1 @@
+blank.hwpx from neolord0/hwpxlib testFile/tool (Apache-2.0)