@clazic/kordoc 2.7.5 → 2.7.6

package/dist/index.cjs

@@ -3062,9 +3062,6 @@ __export(index_exports, {
   VERSION: () => VERSION,
   blocksToMarkdown: () => blocksToMarkdown,
   compare: () => compare,
-  convertHwpToPdf: () => convertHwpToPdf,
-  convertHwpxToPdf: () => convertHwpxToPdf,
-  convertToPdf: () => convertToPdf,
   detectFormat: () => detectFormat,
   detectZipFormat: () => detectZipFormat,
   diffBlocks: () => diffBlocks,
@@ -3084,7 +3081,7 @@ __export(index_exports, {
   runUnifiedOcrPipeline: () => runUnifiedOcrPipeline
 });
 module.exports = __toCommonJS(index_exports);
-var import_promises5 = require("fs/promises");
+var import_promises3 = require("fs/promises");
 
 // src/detect.ts
 var import_jszip = __toESM(require("jszip"), 1);
@@ -3137,7 +3134,7 @@ var import_jszip2 = __toESM(require("jszip"), 1);
 var import_xmldom = require("@xmldom/xmldom");
 
 // src/utils.ts
-var VERSION = true ? "2.7.4" : "0.0.0-dev";
+var VERSION = true ? "2.7.6" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -3344,13 +3341,21 @@ function sanitizeText(text) {
   }
   return result;
 }
+function escapeGfm(text, inTableCell = false) {
+  if (!text) return text;
+  let result = text.replace(/(?<!\\)~/g, "\\~");
+  if (inTableCell) {
+    result = result.replace(/(?<!\\)\|/g, "\\|");
+  }
+  return result;
+}
 function blocksToMarkdown(blocks) {
   const lines = [];
   for (let i = 0; i < blocks.length; i++) {
     const block = blocks[i];
     if (block.type === "heading" && block.text) {
       const prefix = "#".repeat(Math.min(block.level || 2, 6));
-      const headingText = sanitizeText(block.text);
+      const headingText = escapeGfm(sanitizeText(block.text), false);
       if (headingText) lines.push("", `${prefix} ${headingText}`, "");
       continue;
     }
@@ -3363,42 +3368,47 @@ function blocksToMarkdown(blocks) {
       continue;
     }
     if (block.type === "list" && block.text) {
-      const listText = sanitizeText(block.text);
-      if (!listText) continue;
-      const alreadyNumbered = block.listType === "ordered" && /^\d+\.\s/.test(listText);
+      const sanitized = sanitizeText(block.text);
+      if (!sanitized) continue;
+      const alreadyNumbered = block.listType === "ordered" && /^\d+\.\s/.test(sanitized);
       const prefix = alreadyNumbered ? "" : block.listType === "ordered" ? "1. " : "- ";
+      const listText = escapeGfm(sanitized, false);
       lines.push(`${prefix}${listText}`);
       if (block.children) {
         for (const child of block.children) {
           const childPrefix = child.listType === "ordered" ? "1." : "-";
-          lines.push(`  ${childPrefix} ${child.text || ""}`);
+          const childText = child.text ? escapeGfm(sanitizeText(child.text), false) : "";
+          lines.push(`  ${childPrefix} ${childText}`);
         }
       }
       continue;
     }
     if (block.type === "paragraph" && block.text) {
-      let text = sanitizeText(block.text);
-      if (!text) continue;
-      if (/^\[별표\s*\d+/.test(text)) {
+      const sanitized = sanitizeText(block.text);
+      if (!sanitized) continue;
+      if (/^\[별표\s*\d+/.test(sanitized)) {
         const nextBlock = blocks[i + 1];
+        const escapedSelf = escapeGfm(sanitized, false);
         if (nextBlock?.type === "paragraph" && nextBlock.text && /관련\)?$/.test(nextBlock.text)) {
-          lines.push("", `## ${text} ${nextBlock.text}`, "");
+          const nextEscaped = escapeGfm(sanitizeText(nextBlock.text), false);
+          lines.push("", `## ${escapedSelf} ${nextEscaped}`, "");
           i++;
         } else {
-          lines.push("", `## ${text}`, "");
+          lines.push("", `## ${escapedSelf}`, "");
         }
         continue;
       }
-      if (/^\([^)]*조[^)]*관련\)$/.test(text)) {
-        lines.push(`*${text}*`, "");
+      if (/^\([^)]*조[^)]*관련\)$/.test(sanitized)) {
+        lines.push(`*${escapeGfm(sanitized, false)}*`, "");
         continue;
       }
+      let text = escapeGfm(sanitized, false);
       if (block.href) {
         const href = sanitizeHref(block.href);
         if (href) text = `[${text}](${href})`;
       }
       if (block.footnoteText) {
-        text += ` (\uC8FC: ${block.footnoteText})`;
+        text += ` (\uC8FC: ${escapeGfm(block.footnoteText, false)})`;
       }
       lines.push(text);
     } else if (block.type === "table" && block.table) {
@@ -3423,13 +3433,13 @@ function tableToMarkdown(table) {
     return content.split(/\n/).map((line) => {
       const trimmed = line.trim();
       if (!trimmed) return "";
-      if (/^\d+\.\s/.test(trimmed)) return `**${trimmed}**`;
-      if (/^[가-힣]\.\s/.test(trimmed)) return `  ${trimmed}`;
-      return trimmed;
+      if (/^\d+\.\s/.test(trimmed)) return `**${escapeGfm(trimmed, false)}**`;
+      if (/^[가-힣]\.\s/.test(trimmed)) return `  ${escapeGfm(trimmed, false)}`;
+      return escapeGfm(trimmed, false);
     }).filter(Boolean).join("\n");
   }
   if (numCols === 1 && numRows >= 2) {
-    return cells.map((row) => sanitizeText(row[0].text).replace(/\n/g, " ")).filter(Boolean).join("\n");
+    return cells.map((row) => escapeGfm(sanitizeText(row[0].text).replace(/\n/g, " "), false)).filter(Boolean).join("\n");
   }
   const display = Array.from({ length: numRows }, () => Array(numCols).fill(""));
   const skip = /* @__PURE__ */ new Set();
@@ -3438,7 +3448,7 @@ function tableToMarkdown(table) {
       if (skip.has(`${r},${c}`)) continue;
       const cell = cells[r]?.[c];
       if (!cell) continue;
-      display[r][c] = sanitizeText(cell.text).replace(/\n/g, "<br>");
+      display[r][c] = escapeGfm(sanitizeText(cell.text).replace(/\n/g, "<br>"), true);
       for (let dr = 0; dr < cell.rowSpan; dr++) {
         for (let dc = 0; dc < cell.colSpan; dc++) {
           if (dr === 0 && dc === 0) continue;
@@ -3485,6 +3495,223 @@ var HEADING_RATIO_H1 = 1.5;
 var HEADING_RATIO_H2 = 1.3;
 var HEADING_RATIO_H3 = 1.15;
 
+// src/hwp5/equation.ts
+var WORD_COMMANDS = /* @__PURE__ */ new Map([
+  ["alpha", "\\alpha"],
+  ["beta", "\\beta"],
+  ["gamma", "\\gamma"],
+  ["delta", "\\delta"],
+  ["epsilon", "\\epsilon"],
+  ["theta", "\\theta"],
+  ["lambda", "\\lambda"],
+  ["mu", "\\mu"],
+  ["pi", "\\pi"],
+  ["sigma", "\\sigma"],
+  ["tau", "\\tau"],
+  ["phi", "\\phi"],
+  ["omega", "\\omega"],
+  ["sin", "\\sin"],
+  ["cos", "\\cos"],
+  ["tan", "\\tan"],
+  ["sec", "\\sec"],
+  ["csc", "\\csc"],
+  ["cot", "\\cot"],
+  ["log", "\\log"],
+  ["ln", "\\ln"],
+  ["lim", "\\lim"],
+  ["inf", "\\infty"],
+  ["sum", "\\sum"],
+  ["smallsum", "\\sum"],
+  ["prod", "\\prod"],
+  ["int", "\\int"],
+  ["oint", "\\oint"],
+  ["rightarrow", "\\rightarrow"],
+  ["leftarrow", "\\leftarrow"],
+  ["partial", "\\partial"],
+  ["nabla", "\\nabla"],
+  ["angle", "\\angle"],
+  ["triangle", "\\triangle"],
+  ["vec", "\\vec"],
+  ["bar", "\\overline"],
+  ["dot", "\\dot"],
+  ["hat", "\\hat"],
+  ["left", "\\left"],
+  ["right", "\\right"]
+]);
+var SYMBOL_WORDS = /* @__PURE__ */ new Map([
+  ["times", "\\times"],
+  ["divide", "\\div"],
+  ["div", "\\div"],
+  ["le", "\\leq"],
+  ["ge", "\\geq"],
+  ["geq", "\\geq"],
+  ["deg", "^\\circ"],
+  ["rarrow", "\\rightarrow"],
+  ["larrow", "\\leftarrow"],
+  ["lrarrow", "\\leftrightarrow"],
+  ["in", "\\in"],
+  ["notin", "\\notin"],
+  ["emptyset", "\\emptyset"],
+  ["subset", "\\subset"],
+  ["nsubset", "\\nsubseteq"],
+  ["cup", "\\cup"],
+  ["cap", "\\cap"],
+  ["smallinter", "\\cap"],
+  ["sim", "\\sim"],
+  ["circ", "\\circ"],
+  ["bot", "\\perp"],
+  ["dyad", "\\overleftrightarrow"],
+  ["arch", "\\overset{\\frown}"]
+]);
+function hwpEquationToLatex(equation) {
+  return convertEquation(equation.replace(/\0/g, "").trim(), 0);
+}
+function convertEquation(equation, depth) {
+  if (!equation || depth > 12) return equation;
+  let result = equation.replace(/\s+/g, " ").replace(/`+/g, "\\,").replace(/~+/g, "\\,").trim();
+  result = convertMatrixLike(result);
+  result = convertRoots(result, depth);
+  result = convertOver(result, depth);
+  result = convertSqrt(result, depth);
+  result = convertScripts(result);
+  result = convertOperators(result);
+  result = removeFontDirectives(result);
+  result = convertWords(result);
+  result = cleanupLatexSpacing(result);
+  return result;
+}
+function convertMatrixLike(input) {
+  return input.replace(
+    /\bmatrix\s*\{([^{}]*)\}/gi,
+    (_match, body) => `\\begin{matrix} ${body.split("#").map((part) => part.trim()).join(" & ")} \\end{matrix}`
+  ).replace(
+    /\bcases\s*\{([^{}]*)\}/gi,
+    (_match, body) => `\\begin{cases} ${body.split("#").map((part) => part.trim()).join(" \\\\ ")} \\end{cases}`
+  );
+}
+function convertRoots(input, depth) {
+  return input.replace(/(?<!\\)\broot\s+({[^{}]*}|\S+)\s+of\s+({[^{}]*}|\S+)/gi, (_match, degree, radicand) => {
+    return `\\sqrt[${convertEquation(unwrapGroup(degree), depth + 1)}]{${convertEquation(unwrapGroup(radicand), depth + 1)}}`;
+  });
+}
+function convertSqrt(input, depth) {
+  return input.replace(/(?<!\\)\bsqrt\s*({[^{}]*}|\S+)/gi, (_match, radicand) => {
+    return `\\sqrt{${convertEquation(unwrapGroup(radicand), depth + 1)}}`;
+  });
+}
+function convertOver(input, depth) {
+  let result = input;
+  for (let guard = 0; guard < 50; guard++) {
+    const over = findTopLevelWord(result, "over");
+    if (over < 0) break;
+    const left = readLeftAtom(result, over);
+    const right = readRightAtom(result, over + "over".length);
+    if (!left || !right) break;
+    const numerator = convertEquation(unwrapGroup(left.atom), depth + 1);
+    const denominator = convertEquation(unwrapGroup(right.atom), depth + 1);
+    result = result.slice(0, left.start) + `\\frac{${numerator}}{${denominator}}` + result.slice(right.end);
+  }
+  return result;
+}
+function convertScripts(input) {
+  return input.replace(/\s*\^\s*/g, "^").replace(/\s*_\s*/g, "_").replace(/\^(?!\{)([^\s{}_^]+)/g, "^{$1}").replace(/_(?!\{)([^\s{}_^]+)/g, "_{$1}");
+}
+function convertOperators(input) {
+  return input.replace(/\+-/g, "\\pm").replace(/-\+/g, "\\mp").replace(/\/\//g, "\\parallel").replace(/△/g, "\\triangle ").replace(/□/g, "\\square ").replace(/‧/g, "\\cdot ").replace(/!=/g, "\\neq").replace(/<=/g, "\\leq").replace(/>=/g, "\\geq").replace(/==/g, "\\equiv");
+}
+function removeFontDirectives(input) {
+  return input.replace(/(?<!\\)\b(?:rm|it)\b\s*/gi, "");
+}
+function convertWords(input) {
+  return input.replace(/(?<![\\A-Za-z0-9])([A-Za-z][A-Za-z0-9]*)(?![A-Za-z0-9])/g, (word) => {
+    const exact = SYMBOL_WORDS.get(word);
+    if (exact) return exact;
+    const lower = word.toLowerCase();
+    return SYMBOL_WORDS.get(lower) ?? WORD_COMMANDS.get(lower) ?? word;
+  });
+}
+function cleanupLatexSpacing(input) {
+  return input.replace(/\\left\s*\{/g, "\\left\\{").replace(/\\right\s*\}/g, "\\right\\}").replace(/\\left\s*([\[\]\(\)\|])/g, "\\left$1").replace(/\\right\s*([\[\]\(\)\|])/g, "\\right$1").replace(/\s*\\,\s*/g, "\\,").replace(/\s+/g, " ").replace(/\{\s+/g, "{").replace(/\s+\}/g, "}").trim();
+}
+function findTopLevelWord(input, word) {
+  let curly = 0;
+  let paren = 0;
+  for (let i = 0; i <= input.length - word.length; i++) {
+    const ch = input[i];
+    if (ch === "{") curly++;
+    else if (ch === "}") curly = Math.max(0, curly - 1);
+    else if (ch === "(") paren++;
+    else if (ch === ")") paren = Math.max(0, paren - 1);
+    if (curly !== 0 || paren !== 0) continue;
+    if (input.slice(i, i + word.length).toLowerCase() !== word) continue;
+    if (isWordChar(input[i - 1]) || isWordChar(input[i + word.length])) continue;
+    return i;
+  }
+  return -1;
+}
+function readLeftAtom(input, end) {
+  let pos = end - 1;
+  while (pos >= 0 && /\s/.test(input[pos])) pos--;
+  if (pos < 0) return null;
+  if (input[pos] === "}") {
+    const start2 = findMatchingLeft(input, pos, "{", "}");
+    if (start2 >= 0) return { start: start2, atom: input.slice(start2, pos + 1) };
+  }
+  if (input[pos] === ")") {
+    const start2 = findMatchingLeft(input, pos, "(", ")");
+    if (start2 >= 0) return { start: start2, atom: input.slice(start2, pos + 1) };
+  }
+  let start = pos;
+  while (start >= 0 && !/\s/.test(input[start]) && !/[+\-=<>]/.test(input[start])) start--;
+  return { start: start + 1, atom: input.slice(start + 1, pos + 1) };
+}
+function readRightAtom(input, start) {
+  let pos = start;
+  while (pos < input.length && /\s/.test(input[pos])) pos++;
+  if (pos >= input.length) return null;
+  if (input[pos] === "{") {
+    const end2 = findMatchingRight(input, pos, "{", "}");
+    if (end2 >= 0) return { end: end2 + 1, atom: input.slice(pos, end2 + 1) };
+  }
+  if (input[pos] === "(") {
+    const end2 = findMatchingRight(input, pos, "(", ")");
+    if (end2 >= 0) return { end: end2 + 1, atom: input.slice(pos, end2 + 1) };
+  }
+  let end = pos;
+  while (end < input.length && !/\s/.test(input[end]) && !/[+\-=<>]/.test(input[end])) end++;
+  return { end, atom: input.slice(pos, end) };
+}
+function findMatchingLeft(input, closeIndex, open, close) {
+  let depth = 0;
+  for (let i = closeIndex; i >= 0; i--) {
+    if (input[i] === close) depth++;
+    else if (input[i] === open) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function findMatchingRight(input, openIndex, open, close) {
+  let depth = 0;
+  for (let i = openIndex; i < input.length; i++) {
+    if (input[i] === open) depth++;
+    else if (input[i] === close) {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function unwrapGroup(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) return trimmed.slice(1, -1);
+  return trimmed;
+}
+function isWordChar(ch) {
+  return !!ch && /[A-Za-z0-9_]/.test(ch);
+}
+
 // src/hwpx/parser.ts
 init_page_range();
 init_logger();
@@ -4166,6 +4393,17 @@ function findDescendant(node, targetTag, depth = 0) {
   }
   return null;
 }
+function findChildByLocalName(node, targetTag) {
+  const children = node.childNodes;
+  if (!children) return null;
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (child.nodeType !== 1) continue;
+    const tag = (child.tagName || child.localName || "").replace(/^[^:]+:/, "");
+    if (tag === targetTag) return child;
+  }
+  return null;
+}
 function extractDrawTextBlocks(drawTextNode, blocks, styleMap, sectionNum) {
   const children = drawTextNode.childNodes;
   if (!children) return;
@@ -4268,6 +4506,22 @@ function extractParagraphInfo(para, styleMap) {
         case "shapeComment":
         case "drawText":
           break;
+        // 수식: <hp:equation> 내부의 <hp:script>에 HML/HULK-style 수식 본문이
+        // 들어있음. hwpEquationToLatex로 LaTeX 변환 후 `$...$`로 래핑하여
+        // 본문 텍스트에 인라인 삽입. 변환 실패/빈 결과는 조용히 드롭
+        // (대체 텍스트 "수식입니다." 누출 방지는 기존 정규식이 처리).
+        case "equation": {
+          const script = findChildByLocalName(child, "script");
+          const raw = script ? extractTextFromNode(script) : "";
+          if (raw.trim()) {
+            try {
+              const latex = hwpEquationToLatex(raw).trim();
+              if (latex) text += " $" + latex.replace(/\$/g, "\\$") + "$ ";
+            } catch {
+            }
+          }
+          break;
+        }
         // run 요소에서 charPrIDRef 추출
         case "r": {
           const runCharPr = child.getAttribute("charPrIDRef");
@@ -4334,8 +4588,13 @@ var TAG_CHAR_SHAPE = 68;
 var TAG_CTRL_HEADER = 71;
 var TAG_LIST_HEADER = 72;
 var TAG_TABLE = 77;
-var TAG_DOC_CHAR_SHAPE = 55;
-var TAG_DOC_STYLE = 58;
+var TAG_EQEDIT = 88;
+var HWPTAG_BEGIN = 16;
+var TAG_ID_MAPPINGS = HWPTAG_BEGIN + 1;
+var TAG_FACE_NAME = HWPTAG_BEGIN + 3;
+var TAG_DOC_CHAR_SHAPE = HWPTAG_BEGIN + 5;
+var TAG_DOC_PARA_SHAPE = HWPTAG_BEGIN + 9;
+var TAG_DOC_STYLE = HWPTAG_BEGIN + 10;
 var CHAR_LINE = 0;
 var CHAR_SECTION_BREAK = 10;
 var CHAR_PARA = 13;
@@ -4493,6 +4752,15 @@ function extractText(data) {
   }
   return result;
 }
+function extractEquationText(data) {
+  if (data.length < 6) return null;
+  const scriptLength = data.readUInt16LE(4);
+  const scriptStart = 6;
+  const scriptEnd = scriptStart + scriptLength * 2;
+  if (scriptLength <= 0 || scriptEnd > data.length) return null;
+  const equation = data.subarray(scriptStart, scriptEnd).toString("utf16le").replace(/\0+/g, "").trim();
+  return equation || null;
+}
 
 // src/hwp5/aes.ts
 var S_BOX = new Uint8Array([
@@ -5652,6 +5920,26 @@ function findViewTextSectionsLenient(lcfb, compressed) {
   return sections.sort((a, b) => a.idx - b.idx).map((s) => s.content);
 }
 var TAG_SHAPE_COMPONENT = 74;
+var CTRL_ID_EQEDIT = "deqe";
+function isEquationControlId(ctrlId) {
+  return ctrlId === CTRL_ID_EQEDIT || ctrlId === "eqed";
+}
+function formatEquationForMarkdown(equation) {
+  const normalized = hwpEquationToLatex(equation);
+  if (!normalized) return "";
+  return `$${normalized.replace(/\$/g, "\\$")}$`;
+}
+function extractEquationFromControl(records, ctrlIdx) {
+  const ctrlLevel = records[ctrlIdx].level;
+  for (let j = ctrlIdx + 1; j < records.length && j < ctrlIdx + 10; j++) {
+    const r = records[j];
+    if (r.level <= ctrlLevel) break;
+    if (r.tagId !== TAG_EQEDIT) continue;
+    const equation = extractEquationText(r.data);
+    return equation ? formatEquationForMarkdown(equation) : null;
+  }
+  return null;
+}
 function extractBinDataId(records, ctrlIdx) {
   const ctrlLevel = records[ctrlIdx].level;
   for (let j = ctrlIdx + 1; j < records.length && j < ctrlIdx + 50; j++) {
@@ -5811,6 +6099,16 @@ function parseSection(records, docInfo, warnings, sectionNum) {
         }
       } else if (ctrlId === " elo" || ctrlId === "ole ") {
         warnings.push({ page: sectionNum, message: `\uC2A4\uD0B5\uB41C \uC81C\uC5B4 \uC694\uC18C: ${ctrlId.trim()}`, code: "SKIPPED_IMAGE" });
+      } else if (isEquationControlId(ctrlId)) {
+        const equation = extractEquationFromControl(records, i);
+        if (equation) {
+          const lastBlock = blocks[blocks.length - 1];
+          if (lastBlock && lastBlock.type === "paragraph" && lastBlock.text) {
+            lastBlock.text = lastBlock.text + " " + equation;
+          } else {
+            blocks.push({ type: "paragraph", text: equation, pageNumber: sectionNum });
+          }
+        }
       } else if (ctrlId === "fn  " || ctrlId === " nf " || ctrlId === "en  " || ctrlId === " ne ") {
         const noteText = extractNoteText(records, i);
         if (noteText && blocks.length > 0) {
@@ -5843,6 +6141,13 @@ function extractNoteText(records, ctrlIdx) {
       const t = extractText(r.data).trim();
       if (t) texts.push(t);
     }
+    if (r.tagId === TAG_CTRL_HEADER && r.data.length >= 4) {
+      const innerCtrlId = r.data.subarray(0, 4).toString("ascii");
+      if (isEquationControlId(innerCtrlId)) {
+        const equation = extractEquationFromControl(records, j);
+        if (equation) texts.push(equation);
+      }
+    }
   }
   return texts.length > 0 ? texts.join(" ") : null;
 }
@@ -5856,6 +6161,13 @@ function extractTextBoxText(records, ctrlIdx) {
       const t = extractText(r.data).trim();
       if (t) texts.push(t);
     }
+    if (r.tagId === TAG_CTRL_HEADER && r.data.length >= 4) {
+      const innerCtrlId = r.data.subarray(0, 4).toString("ascii");
+      if (isEquationControlId(innerCtrlId)) {
+        const equation = extractEquationFromControl(records, j);
+        if (equation) texts.push(equation);
+      }
+    }
   }
   return texts.length > 0 ? texts.join("\n") : null;
 }
@@ -5924,6 +6236,12 @@ function parseParagraphWithTables(records, startIdx) {
         i = nextIdx;
         continue;
       }
+      if (isEquationControlId(ctrlId)) {
+        const equation = extractEquationFromControl(records, i);
+        if (equation) {
+          text = text ? text + " " + equation : equation;
+        }
+      }
     }
     i++;
   }
@@ -11233,528 +11551,6 @@ async function markdownToXlsx(markdown, options) {
   return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
 }
 
-// src/convert/index.ts
-var import_promises3 = require("fs/promises");
-
-// src/convert/libreoffice.ts
-var import_libreoffice_convert = __toESM(require("libreoffice-convert"), 1);
-
-// src/convert/error.ts
-var ConvertError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "ConvertError";
-  }
-};
-
-// src/convert/installer.ts
-var import_os3 = require("os");
-var import_path5 = require("path");
-var import_promises2 = require("fs/promises");
-var import_fs4 = require("fs");
-var import_child_process4 = require("child_process");
-var installInFlight = null;
-var CACHE_DIR = (0, import_path5.join)((0, import_os3.homedir)(), ".cache", "kordoc", "libreoffice");
-var VERSION_FILE = (0, import_path5.join)(CACHE_DIR, "version");
-var PACKAGES = {
-  darwin: {
-    url: "https://ftp.osuosl.org/pub/tdf/libreoffice/stable/26.2.3/mac/x86_64/LibreOffice_26.2.3_MacOS_x86-64.dmg",
-    binPath: "LibreOffice.app/Contents/MacOS/soffice",
-    sizeMb: 300
-  },
-  linux: {
-    url: "https://ftp.osuosl.org/pub/tdf/libreoffice/stable/26.2.3/deb/x86_64/LibreOffice_26.2.3_Linux_x86-64_deb.tar.gz",
-    binPath: "opt/libreoffice26.2/program/soffice",
-    sizeMb: 210
-  },
-  win32: {
-    url: "https://ftp.osuosl.org/pub/tdf/libreoffice/stable/26.2.3/win/x86_64/LibreOffice_26.2.3_Win_x86-64.msi",
-    binPath: "LibreOffice/program/soffice.exe",
-    sizeMb: 360
-  }
-};
-async function findInPath() {
-  return new Promise((resolve4) => {
-    const child = (0, import_child_process4.spawn)("soffice", ["--version"], { stdio: "ignore" });
-    child.on("close", (code) => resolve4(code === 0 ? "soffice" : null));
-    child.on("error", () => resolve4(null));
-  });
-}
-async function findInCache() {
-  const cachedBin = (0, import_path5.join)(CACHE_DIR, "bin", "soffice");
-  try {
-    await (0, import_promises2.access)(cachedBin);
-    return cachedBin;
-  } catch {
-    return null;
-  }
-}
-async function findInDefaultPaths() {
-  const platform = process.platform;
-  const paths = [];
-  if (platform === "darwin") {
-    paths.push(
-      "/Applications/LibreOffice.app/Contents/MacOS/soffice",
-      "/opt/homebrew/bin/soffice",
-      "/usr/local/bin/soffice"
-    );
-  } else if (platform === "linux") {
-    paths.push(
-      "/usr/bin/soffice",
-      "/usr/lib/libreoffice/program/soffice"
-    );
-  } else if (platform === "win32") {
-    const pf = process.env["ProgramFiles"] ?? "C:\\Program Files";
-    const pf86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    paths.push(
-      (0, import_path5.join)(pf, "LibreOffice", "program", "soffice.exe"),
-      (0, import_path5.join)(pf86, "LibreOffice", "program", "soffice.exe")
-    );
-  }
-  for (const p of paths) {
-    try {
-      await (0, import_promises2.access)(p);
-      return p;
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-async function downloadWithProgress(url, dest, totalBytes, onProgress) {
-  const response = await fetch(url);
-  if (!response.ok) throw new Error(`\uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: HTTP ${response.status} (${url})`);
-  if (!response.body) throw new Error("\uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: response body \uC5C6\uC74C");
-  const file = (0, import_fs4.createWriteStream)(dest);
-  const reader = response.body.getReader();
-  let downloaded = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!file.write(value)) {
-        await new Promise((resolve4) => file.once("drain", resolve4));
-      }
-      downloaded += value.length;
-      onProgress?.(downloaded, totalBytes);
-    }
-  } finally {
-    reader.releaseLock();
-    await new Promise((resolve4, reject) => {
-      file.end((err) => err ? reject(err) : resolve4());
-    });
-  }
-}
-async function installForPlatform(pkg, onProgress) {
-  const platform = process.platform;
-  await (0, import_promises2.mkdir)(CACHE_DIR, { recursive: true });
-  const downloadPath = (0, import_path5.join)(CACHE_DIR, `download-${Date.now()}`);
-  await downloadWithProgress(pkg.url, downloadPath, pkg.sizeMb * 1024 * 1024, onProgress);
-  try {
-    if (platform === "darwin") {
-      return await installMacOS(pkg, downloadPath);
-    } else if (platform === "linux") {
-      return await installLinux(pkg, downloadPath);
-    } else if (platform === "win32") {
-      return await installWindows(pkg, downloadPath);
-    }
-  } catch (err) {
-    await (0, import_promises2.rm)(downloadPath, { force: true });
-    throw err;
-  }
-  throw new ConvertError("UNSUPPORTED_PLATFORM", `${platform}\uC740 \uC790\uB3D9 \uC124\uCE58\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4`);
-}
-async function installMacOS(pkg, downloadPath) {
-  const mountPoint = `/Volumes/LibreOffice_${Date.now()}`;
-  await new Promise((resolve4, reject) => {
-    const stderr = [];
-    const child = (0, import_child_process4.spawn)("hdiutil", ["attach", "-nobrowse", "-noverify", "-mountpoint", mountPoint, downloadPath]);
-    child.stderr?.on("data", (d) => stderr.push(d.toString()));
-    child.on(
-      "close",
-      (code) => code === 0 ? resolve4() : reject(new Error(`dmg \uB9C8\uC6B4\uD2B8 \uC2E4\uD328 (code=${code}): ${stderr.join("").trim()}`))
-    );
-  });
-  try {
-    const appSource = (0, import_path5.join)(mountPoint, "LibreOffice.app");
-    const appDest = (0, import_path5.join)(CACHE_DIR, "LibreOffice.app");
-    await new Promise((resolve4, reject) => {
-      const child = (0, import_child_process4.spawn)("cp", ["-R", appSource, appDest]);
-      child.on("close", (code) => code === 0 ? resolve4() : reject(new Error(".app \uBCF5\uC0AC \uC2E4\uD328")));
-    });
-  } finally {
-    await new Promise((resolve4) => {
-      const child = (0, import_child_process4.spawn)("hdiutil", ["detach", mountPoint]);
-      child.on("close", () => resolve4());
-    });
-  }
-  await (0, import_promises2.rm)(downloadPath, { force: true });
-  return await createSymlink((0, import_path5.join)(CACHE_DIR, pkg.binPath));
-}
-async function installLinux(pkg, downloadPath) {
-  const extractDir = (0, import_path5.join)(CACHE_DIR, `extract-${Date.now()}`);
-  await (0, import_promises2.mkdir)(extractDir, { recursive: true });
-  await new Promise((resolve4, reject) => {
-    const child = (0, import_child_process4.spawn)("tar", ["xzf", downloadPath, "-C", extractDir]);
-    child.on("close", (code) => code === 0 ? resolve4() : reject(new Error("\uC555\uCD95 \uD574\uC81C \uC2E4\uD328")));
-  });
-  const debsDir = (0, import_path5.join)(extractDir, "DEBS");
-  try {
-    await (0, import_promises2.access)(debsDir);
-    const entries = await (await import("fs/promises")).readdir(debsDir);
-    for (const entry of entries) {
-      if (entry.endsWith(".deb")) {
-        await new Promise((resolve4, reject) => {
-          const child = (0, import_child_process4.spawn)("dpkg-deb", ["-x", (0, import_path5.join)(debsDir, entry), CACHE_DIR]);
-          child.on("close", (code) => code === 0 ? resolve4() : reject(new Error(`${entry} \uCD94\uCD9C \uC2E4\uD328`)));
-        });
-      }
-    }
-  } catch {
-  }
-  await (0, import_promises2.rm)(downloadPath, { force: true });
-  await (0, import_promises2.rm)(extractDir, { recursive: true, force: true });
-  return await createSymlink((0, import_path5.join)(CACHE_DIR, pkg.binPath));
-}
-async function installWindows(pkg, downloadPath) {
-  await new Promise((resolve4, reject) => {
-    const child = (0, import_child_process4.spawn)("msiexec", ["/a", downloadPath, "/qn", `TARGETDIR=${CACHE_DIR}`]);
-    child.on("close", (code) => code === 0 ? resolve4() : reject(new Error("MSI \uC124\uCE58 \uC2E4\uD328")));
-  });
-  await (0, import_promises2.rm)(downloadPath, { force: true });
-  return (0, import_path5.join)(CACHE_DIR, pkg.binPath);
-}
-async function createSymlink(actualBin) {
-  const binDir = (0, import_path5.join)(CACHE_DIR, "bin");
-  await (0, import_promises2.mkdir)(binDir, { recursive: true });
-  const linkBin = (0, import_path5.join)(binDir, "soffice");
-  try {
-    await (0, import_promises2.symlink)(actualBin, linkBin);
-  } catch {
-  }
-  process.env.PATH = `${binDir}${import_path5.delimiter}${process.env.PATH}`;
-  return linkBin;
-}
-async function installLibreOffice(onProgress) {
-  const platform = process.platform;
-  const pkg = PACKAGES[platform];
-  if (!pkg) {
-    throw new ConvertError(
-      "UNSUPPORTED_PLATFORM",
-      `${platform}\uC740 \uC790\uB3D9 \uC124\uCE58\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4. \uC218\uB3D9\uC73C\uB85C LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694.`
-    );
-  }
-  return await installForPlatform(pkg, onProgress);
-}
-async function resolveSoffice(emitter, autoInstall = true) {
-  emitter.validate("soffice_check", "LibreOffice \uAC00\uC6A9\uC131 \uD655\uC778 \uC911...");
-  const inPath = await findInPath();
-  if (inPath) {
-    emitter.validate("soffice_found", "\uC2DC\uC2A4\uD15C PATH\uC5D0\uC11C LibreOffice \uBC1C\uACAC", { sofficePath: inPath });
-    return inPath;
-  }
-  const inCache = await findInCache();
-  if (inCache) {
-    emitter.validate("soffice_found", "\uCE90\uC2DC\uB41C LibreOffice \uBC1C\uACAC", { sofficePath: inCache });
-    return inCache;
-  }
-  const inDefault = await findInDefaultPaths();
-  if (inDefault) {
-    emitter.validate("soffice_found", "\uAE30\uBCF8 \uACBD\uB85C\uC5D0\uC11C LibreOffice \uBC1C\uACAC", { sofficePath: inDefault });
-    return inDefault;
-  }
-  if (!autoInstall) {
-    emitter.error(
-      "validate",
-      "SOFFICE_NOT_FOUND",
-      "LibreOffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
-      "\uC218\uB3D9\uC73C\uB85C \uC124\uCE58\uD558\uAC70\uB098 autoInstallLibreOffice: true \uC635\uC158\uC744 \uC0AC\uC6A9\uD558\uC138\uC694."
-    );
-    throw new ConvertError("SOFFICE_NOT_FOUND", "LibreOffice\uAC00 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4");
-  }
-  if (installInFlight) {
-    return installInFlight;
-  }
-  emitter.install("install_start", "LibreOffice \uC790\uB3D9 \uC124\uCE58\uB97C \uC2DC\uC791\uD569\uB2C8\uB2E4...");
-  installInFlight = (async () => {
-    try {
-      const installed = await installLibreOffice((downloaded, total) => {
-        const percent = Math.round(downloaded / total * 100);
-        emitter.install("download_progress", `\uB2E4\uC6B4\uB85C\uB4DC \uC911... ${percent}%`, {
-          percent,
-          downloadedBytes: downloaded,
-          totalBytes: total
-        });
-      });
-      emitter.install("install_complete", "\uC124\uCE58 \uC644\uB8CC", { installedPath: installed });
-      return installed;
-    } catch (err) {
-      const errorMsg = err instanceof Error ? err.message : String(err);
-      emitter.install("install_failed", "\uC124\uCE58 \uC2E4\uD328", { error: errorMsg });
-      throw err;
-    } finally {
-      installInFlight = null;
-    }
-  })();
-  return installInFlight;
-}
-
-// src/convert/libreoffice.ts
-var libreConvert = import_libreoffice_convert.default.convert;
-var libreConvertWithOptions = import_libreoffice_convert.default.convertWithOptions;
-async function convertBuffer(buffer, targetExt, timeoutMs = 6e4, sofficePath, sourceExt) {
-  return new Promise((resolve4, reject) => {
-    const timer = setTimeout(() => {
-      reject(
-        new ConvertError("TIMEOUT", `\uBCC0\uD658 \uD0C0\uC784\uC544\uC6C3 (${timeoutMs}ms \uCD08\uACFC)`)
-      );
-    }, timeoutMs);
-    const cb = (err, done) => {
-      clearTimeout(timer);
-      if (err || !done) {
-        reject(
-          new ConvertError(
-            "CONVERT_FAILED",
-            err?.message ?? "LibreOffice \uBCC0\uD658 \uC2E4\uD328"
-          )
-        );
-        return;
-      }
-      resolve4(done);
-    };
-    if (sofficePath) {
-      const fileName = sourceExt ? `source${sourceExt}` : "source";
-      libreConvertWithOptions(buffer, targetExt, void 0, { sofficeBinaryPaths: [sofficePath], fileName }, cb);
-    } else {
-      libreConvert(buffer, targetExt, void 0, cb);
-    }
-  });
-}
-
-// src/convert/events.ts
-var ConvertEventEmitter = class {
-  listener = null;
-  /** 이벤트 리스너 등록 */
-  setListener(listener) {
-    this.listener = listener;
-  }
-  /** 이벤트 발송 */
-  emit(event) {
-    try {
-      this.listener?.(event);
-    } catch {
-    }
-  }
-  /** 타입 안전한 헬퍼: detect 이벤트 */
-  detect(stage, message, meta) {
-    this.emit({ type: "detect", stage, message, ...meta });
-  }
-  /** 타입 안전한 헬퍼: validate 이벤트 */
-  validate(stage, message, meta) {
-    this.emit({ type: "validate", stage, message, ...meta });
-  }
-  /** 타입 안전한 헬퍼: install 이벤트 */
-  install(stage, message, meta) {
-    this.emit({ type: "install", stage, message, ...meta });
-  }
-  /** 타입 안전한 헬퍼: convert 진행 이벤트 */
-  progress(percent, message) {
-    this.emit({ type: "convert", stage: "convert_progress", message, percent });
-  }
-  /** 타입 안전한 헬퍼: convert 시작 */
-  convertStart(message) {
-    this.emit({ type: "convert", stage: "convert_start", message, percent: 0 });
-  }
-  /** 타입 안전한 헬퍼: convert 완료 */
-  convertDone(message) {
-    this.emit({ type: "convert", stage: "convert_done", message, percent: 100 });
-  }
-  /** 타입 안전한 헬퍼: 완료 이벤트 */
-  complete(result) {
-    this.emit({ type: "complete", stage: "success", message: "\uBCC0\uD658 \uC644\uB8CC", result });
-  }
-  /** 타입 안전한 헬퍼: 에러 이벤트 */
-  error(stage, code, message, suggestion) {
-    this.emit({ type: "error", stage, code, message, recoverable: true, suggestion });
-  }
-};
-
-// src/convert/index.ts
-var isConverting = false;
-var queue = [];
-async function acquireConvertLock() {
-  if (!isConverting) {
-    isConverting = true;
-    return () => {
-      isConverting = false;
-      const next = queue.shift();
-      next?.();
-    };
-  }
-  return new Promise((resolve4) => {
-    queue.push(() => {
-      isConverting = true;
-      resolve4(() => {
-        isConverting = false;
-        const next = queue.shift();
-        next?.();
-      });
-    });
-  });
-}
-async function convertToPdf(input, options) {
-  const emitter = new ConvertEventEmitter();
-  if (options?.onEvent) {
-    emitter.setListener(options.onEvent);
-  }
-  if (options?.onProgress) {
-    const legacyProgress = options.onProgress;
-    emitter.setListener((event) => {
-      if (event.type === "convert" && event.stage === "convert_progress") {
-        legacyProgress(event.percent, event.message);
-      }
-    });
-  }
-  try {
-    emitter.detect("reading", "\uC785\uB825 \uD30C\uC77C \uC77D\uB294 \uC911...");
-    let buffer;
-    try {
-      if (typeof input === "string") {
-        buffer = await (0, import_promises3.readFile)(input);
-      } else if (Buffer.isBuffer(input)) {
-        buffer = input;
-      } else {
-        buffer = Buffer.from(input);
-      }
-    } catch (err) {
-      emitter.error(
-        "detect",
-        "PARSE_ERROR",
-        `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`
-      );
-      return {
-        success: false,
-        code: "PARSE_ERROR",
-        error: `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`,
-        stage: "detect"
-      };
-    }
-    const MAX_FILE_SIZE = 500 * 1024 * 1024;
-    if (buffer.length > MAX_FILE_SIZE) {
-      emitter.error(
-        "detect",
-        "FILE_TOO_LARGE",
-        `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`
-      );
-      return {
-        success: false,
-        code: "FILE_TOO_LARGE",
-        error: `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.length / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`,
-        stage: "detect"
-      };
-    }
-    const format = detectFormat(toArrayBuffer(buffer));
-    emitter.detect("format_detected", `\uD3EC\uB9F7 \uAC10\uC9C0 \uC644\uB8CC: ${format}`, { format });
-    if (format !== "hwp" && format !== "hwpx") {
-      emitter.error("detect", "UNSUPPORTED_FORMAT", `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`);
-      return {
-        success: false,
-        code: "UNSUPPORTED_FORMAT",
-        error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`,
-        stage: "detect"
-      };
-    }
-    emitter.validate("soffice_check", "LibreOffice \uAC00\uC6A9\uC131 \uD655\uC778 \uC911...");
-    let sofficePath;
-    try {
-      sofficePath = await resolveSoffice(emitter, options?.autoInstallLibreOffice ?? true);
-    } catch (err) {
-      if (err instanceof ConvertError) {
-        return {
-          success: false,
-          code: err.code,
-          error: err.message,
-          stage: "validate"
-        };
-      }
-      throw err;
-    }
-    const releaseLock = await acquireConvertLock();
-    try {
-      emitter.convertStart("\uBCC0\uD658 \uC2DC\uC791...");
-      emitter.progress(10, "\uBCC0\uD658 \uC911...");
-      const sourceExt = format === "hwpx" ? ".hwpx" : ".hwp";
-      const pdf = await convertBuffer(buffer, ".pdf", options?.timeoutMs, sofficePath, sourceExt);
-      emitter.progress(100, "\uBCC0\uD658 \uC644\uB8CC");
-      emitter.convertDone("\uBCC0\uD658 \uC644\uB8CC");
-      const result = {
-        success: true,
-        pdf: new Uint8Array(pdf),
-        sourceFormat: format
-      };
-      emitter.complete({
-        sourceFormat: format,
-        pdfSize: pdf.length
-      });
-      return result;
-    } catch (err) {
-      if (err instanceof ConvertError) {
-        emitter.error("convert", err.code, err.message);
-        return {
-          success: false,
-          code: err.code,
-          error: err.message,
-          stage: "convert"
-        };
-      }
-      const errorMsg = err instanceof Error ? err.message : "\uBCC0\uD658 \uC2E4\uD328";
-      emitter.error("convert", classifyError(err), errorMsg);
-      return {
-        success: false,
-        code: classifyError(err),
-        error: errorMsg,
-        stage: "convert"
-      };
-    } finally {
-      releaseLock();
-    }
-  } catch (unexpectedErr) {
-    const errorMsg = unexpectedErr instanceof Error ? unexpectedErr.message : "\uC608\uC0C1\uCE58 \uBABB\uD55C \uC624\uB958";
-    emitter.error("convert", "PARSE_ERROR", errorMsg);
-    return {
-      success: false,
-      code: "PARSE_ERROR",
-      error: errorMsg,
-      stage: "convert"
-    };
-  }
-}
-async function convertHwpToPdf(input, options) {
-  const result = await convertToPdf(input, options);
-  if (result.success && result.sourceFormat !== "hwp") {
-    return {
-      success: false,
-      code: "UNSUPPORTED_FORMAT",
-      error: `HWP 5.x \uD3EC\uB9F7\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${result.sourceFormat}`,
-      stage: "detect"
-    };
-  }
-  return result;
-}
-async function convertHwpxToPdf(input, options) {
-  const result = await convertToPdf(input, options);
-  if (result.success && result.sourceFormat !== "hwpx") {
-    return {
-      success: false,
-      code: "UNSUPPORTED_FORMAT",
-      error: `HWPX \uD3EC\uB9F7\uC774 \uC544\uB2D9\uB2C8\uB2E4: ${result.sourceFormat}`,
-      stage: "detect"
-    };
-  }
-  return result;
-}
-
 // src/ocr/api-key-rotation.ts
 var AllKeysCoolingDownError = class extends Error {
   waitMs;
@@ -11849,9 +11645,9 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
 };
 
 // src/pipeline/unified-ocr.ts
-var import_promises4 = require("fs/promises");
-var import_path6 = require("path");
-var import_child_process5 = require("child_process");
+var import_promises2 = require("fs/promises");
+var import_path5 = require("path");
+var import_child_process4 = require("child_process");
 var import_node_perf_hooks = require("perf_hooks");
 init_logger();
 
@@ -11985,15 +11781,15 @@ function elapsedMs(startAt) {
   return Math.round(import_node_perf_hooks.performance.now() - startAt);
 }
 async function runUnifiedOcrPipeline(inputPath, options = {}) {
-  const absInput = (0, import_path6.resolve)(inputPath);
-  const stem = (0, import_path6.basename)(absInput, (0, import_path6.extname)(absInput));
-  const workspaceDir = (0, import_path6.resolve)(options.workspaceDir ?? (0, import_path6.join)((0, import_path6.dirname)(absInput), `${stem}_ocr_workspace`));
-  const imagesDir = (0, import_path6.join)(workspaceDir, "images");
-  const rawDir = (0, import_path6.join)(workspaceDir, "ocr", "raw");
-  const diffDir = (0, import_path6.join)(workspaceDir, "ocr", "diff");
-  const outputPath = (0, import_path6.resolve)(options.outputPath ?? (0, import_path6.join)((0, import_path6.dirname)(absInput), `${stem}.md`));
-  const reportPath = (0, import_path6.join)(workspaceDir, "run-report.json");
-  const modelCachePath = (0, import_path6.join)((0, import_path6.dirname)(absInput), ".kordoc-model-cache.json");
+  const absInput = (0, import_path5.resolve)(inputPath);
+  const stem = (0, import_path5.basename)(absInput, (0, import_path5.extname)(absInput));
+  const workspaceDir = (0, import_path5.resolve)(options.workspaceDir ?? (0, import_path5.join)((0, import_path5.dirname)(absInput), `${stem}_ocr_workspace`));
+  const imagesDir = (0, import_path5.join)(workspaceDir, "images");
+  const rawDir = (0, import_path5.join)(workspaceDir, "ocr", "raw");
+  const diffDir = (0, import_path5.join)(workspaceDir, "ocr", "diff");
+  const outputPath = (0, import_path5.resolve)(options.outputPath ?? (0, import_path5.join)((0, import_path5.dirname)(absInput), `${stem}.md`));
+  const reportPath = (0, import_path5.join)(workspaceDir, "run-report.json");
+  const modelCachePath = (0, import_path5.join)((0, import_path5.dirname)(absInput), ".kordoc-model-cache.json");
   const baseUrl = options.baseUrl ?? "https://integrate.api.nvidia.com/v1/chat/completions";
   const timeoutMs = options.timeoutMs ?? 6e4;
   const maxRetriesPerPage = options.maxRetriesPerPage ?? 5;
@@ -12004,12 +11800,11 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
   const models = sortModelsByCache(modelsInput, modelCache);
   const modelMaxTokens = { ...DEFAULT_MODEL_MAX_TOKENS, ...options.modelMaxTokens ?? {} };
   const stageWeights = normalizeWeights({ ...DEFAULT_STAGE_WEIGHTS, ...options.stageWeights ?? {} });
-  const keyPool = ApiKeyRotationPool.fromEnv();
   const runId = options.runId ?? generateRunId("ocr");
   const logger = (options.logger ?? createLoggerFromEnv()).withRun(runId).child({ component: "pipeline/unified-ocr.ts" });
-  await (0, import_promises4.mkdir)(imagesDir, { recursive: true });
-  await (0, import_promises4.mkdir)(rawDir, { recursive: true });
-  await (0, import_promises4.mkdir)(diffDir, { recursive: true });
+  await (0, import_promises2.mkdir)(imagesDir, { recursive: true });
+  await (0, import_promises2.mkdir)(rawDir, { recursive: true });
+  await (0, import_promises2.mkdir)(diffDir, { recursive: true });
   const timingsMs = {};
   const markStageStart = (stage, message) => emitProgress(options.onEvent, stage, 0, stageWeights, { message, type: "stage_start" });
   const markStageProgress = (stage, stagePercent, current, total, message, model) => emitProgress(options.onEvent, stage, stagePercent, stageWeights, { type: "stage_progress", current, total, message, model });
@@ -12020,52 +11815,57 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
   };
   try {
     ensureSupportedInput(absInput);
-    let workingPdfPath = absInput;
     const convertStart = import_node_perf_hooks.performance.now();
     currentStage = "convert";
-    markStageStart("convert", "\uBB38\uC11C\uB97C PDF\uB85C \uBCC0\uD658 \uC911");
-    logStage("info", "convert", "start", "\uBB38\uC11C\uB97C PDF\uB85C \uBCC0\uD658 \uC2DC\uC791", { input: absInput });
-    if ((0, import_path6.extname)(absInput).toLowerCase() !== ".pdf") {
-      const convertEmitter = new ConvertEventEmitter();
-      if (options.onEvent) {
-        convertEmitter.setListener((evt) => {
-          if (evt.type === "install" || evt.type === "validate" || evt.type === "error") {
-            try {
-              ;
-              options.onEvent(evt);
-            } catch {
-            }
-          }
-        });
-      }
-      let resolvedSofficePath;
-      if (options.sofficePath) {
-        const sofficeDir = (0, import_path6.dirname)(options.sofficePath);
-        process.env.PATH = `${sofficeDir}${import_path6.delimiter}${process.env.PATH ?? ""}`;
-        convertEmitter.validate("soffice_found", "\uC9C1\uC811 \uC9C0\uC815\uB41C LibreOffice \uACBD\uB85C \uC0AC\uC6A9", { sofficePath: options.sofficePath });
-        resolvedSofficePath = options.sofficePath;
-      } else {
-        resolvedSofficePath = await resolveSoffice(convertEmitter, options.autoInstallLibreOffice ?? false);
-      }
-      workingPdfPath = (0, import_path6.join)(workspaceDir, `${stem}.pdf`);
-      const inputBuffer = await (0, import_promises4.readFile)(absInput);
-      const sourceExt = (0, import_path6.extname)(absInput).toLowerCase();
-      const out = await convertBuffer(inputBuffer, ".pdf", 5 * 6e4, resolvedSofficePath, sourceExt);
-      await (0, import_promises4.writeFile)(workingPdfPath, out);
+    if ((0, import_path5.extname)(absInput).toLowerCase() !== ".pdf") {
+      markStageStart("convert", "\uC790\uCCB4 \uD30C\uC11C\uB85C Markdown \uBCC0\uD658 \uC911");
+      logStage("info", "convert", "start", "\uC790\uCCB4 \uD30C\uC11C \uBCC0\uD658 \uC2DC\uC791", { input: absInput });
+      const inputBuffer = await (0, import_promises2.readFile)(absInput);
+      const parsed = await parseNativeDocument(inputBuffer);
+      timingsMs.convert = elapsedMs(convertStart);
+      markStageDone("convert", "\uC790\uCCB4 \uD30C\uC11C \uBCC0\uD658 \uC644\uB8CC");
+      logStage("info", "convert", "done", "\uC790\uCCB4 \uD30C\uC11C \uBCC0\uD658 \uC644\uB8CC", { format: parsed.fileType, elapsedMs: timingsMs.convert });
+      const mergeStart2 = import_node_perf_hooks.performance.now();
+      currentStage = "merge";
+      markStageStart("merge", "Markdown \uC800\uC7A5 \uC911");
+      await (0, import_promises2.writeFile)(outputPath, parsed.markdown, "utf-8");
+      timingsMs.merge = elapsedMs(mergeStart2);
+      markStageDone("merge", "Markdown \uC800\uC7A5 \uC644\uB8CC");
+      logStage("info", "merge", "done", "Markdown \uC800\uC7A5 \uC644\uB8CC", { outputPath, elapsedMs: timingsMs.merge });
+      const report2 = {
+        inputPath: absInput,
+        outputPath,
+        workspaceDir,
+        selectedModel: "native-parser",
+        probeImage: "",
+        probeResults: [],
+        pageCount: parsed.pageCount,
+        sourceFormat: parsed.fileType,
+        keyHealth: [],
+        timingsMs,
+        modelCachePath
+      };
+      await (0, import_promises2.writeFile)(reportPath, JSON.stringify(report2, null, 2), "utf-8");
+      logStage("info", "finalize", "done", "native parse run-report \uC800\uC7A5 \uC644\uB8CC", { reportPath });
+      return { outputPath, reportPath, selectedModel: "native-parser" };
     }
+    const workingPdfPath = absInput;
+    markStageStart("convert", "PDF \uC785\uB825 \uD655\uC778 \uC911");
+    logStage("info", "convert", "start", "PDF \uC785\uB825 \uD655\uC778", { input: absInput });
     timingsMs.convert = elapsedMs(convertStart);
-    markStageDone("convert", "PDF \uBCC0\uD658 \uC644\uB8CC");
-    logStage("info", "convert", "done", "PDF \uBCC0\uD658 \uC644\uB8CC", { elapsedMs: timingsMs.convert });
+    markStageDone("convert", "PDF \uC785\uB825 \uD655\uC778 \uC644\uB8CC");
+    logStage("info", "convert", "done", "PDF \uC785\uB825 \uD655\uC778 \uC644\uB8CC", { elapsedMs: timingsMs.convert });
+    const keyPool = ApiKeyRotationPool.fromEnv();
     const renderStart = import_node_perf_hooks.performance.now();
     currentStage = "render";
     const totalPages = await getPdfPageCount(workingPdfPath).catch(() => 0);
     if (totalPages === 0) throw new UnifiedOcrError("RENDER_FAILED", "render", "\uD398\uC774\uC9C0 \uC218\uB97C \uD655\uC778\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
     markStageStart("render", "PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC911");
     logStage("info", "render", "start", "PDF \uD398\uC774\uC9C0 \uB80C\uB354\uB9C1 \uC2DC\uC791", { pdf: workingPdfPath, dpi, totalPages });
-    await runCommand("pdftoppm", ["-png", "-r", String(dpi), "-f", "1", "-l", "1", workingPdfPath, (0, import_path6.join)(imagesDir, "page")]);
-    const firstFiles = (await (0, import_promises4.readdir)(imagesDir)).filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
+    await runCommand("pdftoppm", ["-png", "-r", String(dpi), "-f", "1", "-l", "1", workingPdfPath, (0, import_path5.join)(imagesDir, "page")]);
+    const firstFiles = (await (0, import_promises2.readdir)(imagesDir)).filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
     if (firstFiles.length === 0) throw new UnifiedOcrError("RENDER_FAILED", "render", "\uCCAB \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC2E4\uD328");
-    const probeImage = (0, import_path6.join)(imagesDir, firstFiles[0]);
+    const probeImage = (0, import_path5.join)(imagesDir, firstFiles[0]);
     markStageProgress("render", Math.round(1 / totalPages * 100), 1, totalPages, `\uD398\uC774\uC9C0 1/${totalPages} \uB80C\uB354\uB9C1`);
     const probeStart = import_node_perf_hooks.performance.now();
     currentStage = "probe";
@@ -12101,7 +11901,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     const keyCount = keyPool.snapshot().length;
     const workerCount = Math.max(1, keyCount * concurrencyPerKey);
     const queueCapacity = workerCount * 2;
-    const queue2 = new BoundedQueue(queueCapacity);
+    const queue = new BoundedQueue(queueCapacity);
     const ocrStart = import_node_perf_hooks.performance.now();
     currentStage = "ocr";
     markStageStart("ocr", `OCR \uC9C4\uD589 \uC911 (\uC6CC\uCEE4 ${workerCount}\uAC1C)`);
@@ -12109,17 +11909,17 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     let renderDone = 1;
     const renderProducer = (async () => {
       try {
-        await queue2.enqueue({ pageNumber: 1, imagePath: probeImage });
+        await queue.enqueue({ pageNumber: 1, imagePath: probeImage });
         if (totalPages > 1) {
-          for await (const item of renderPdfToPngStream(workingPdfPath, (0, import_path6.join)(imagesDir, "page"), dpi, totalPages, 2)) {
-            await queue2.enqueue(item);
+          for await (const item of renderPdfToPngStream(workingPdfPath, (0, import_path5.join)(imagesDir, "page"), dpi, totalPages, 2)) {
+            await queue.enqueue(item);
             renderDone++;
             markStageProgress("render", Math.round(renderDone / totalPages * 100), renderDone, totalPages, `\uD398\uC774\uC9C0 ${renderDone}/${totalPages} \uB80C\uB354\uB9C1`);
             logStage("debug", "render", "progress", "\uD398\uC774\uC9C0 \uB80C\uB354 \uC644\uB8CC", { page: item.pageNumber });
           }
         }
       } finally {
-        queue2.close();
+        queue.close();
         timingsMs.render = elapsedMs(renderStart);
         markStageDone("render", "\uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC");
         logStage("info", "render", "done", "\uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0 \uC0DD\uC131 \uC644\uB8CC", { pages: renderDone, elapsedMs: timingsMs.render });
@@ -12128,7 +11928,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     const [, pageResultsMap] = await Promise.all([
       renderProducer,
       ocrWorkerPool({
-        queue: queue2,
+        queue,
         workerCount,
         totalPages,
         ocrInput: {
@@ -12161,8 +11961,8 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     const sortedEntries = Array.from(pageResultsMap.entries()).sort((a, b) => a[0] - b[0]);
     const rawPagePaths = [];
     for (const [pageNum, markdown] of sortedEntries) {
-      const pagePath = (0, import_path6.join)(rawDir, `page_${String(pageNum).padStart(4, "0")}.md`);
-      await (0, import_promises4.writeFile)(pagePath, markdown, "utf-8");
+      const pagePath = (0, import_path5.join)(rawDir, `page_${String(pageNum).padStart(4, "0")}.md`);
+      await (0, import_promises2.writeFile)(pagePath, markdown, "utf-8");
       rawPagePaths.push(pagePath);
     }
     const mergeStart = import_node_perf_hooks.performance.now();
@@ -12170,7 +11970,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     markStageStart("merge", "\uCD5C\uC885 Markdown \uBCD1\uD569 \uC911");
     logStage("info", "merge", "start", "\uCD5C\uC885 \uBCD1\uD569 \uC2DC\uC791", { pages: rawPagePaths.length });
     const merged = await mergeMarkdownPages(rawPagePaths);
-    await (0, import_promises4.writeFile)(outputPath, merged, "utf-8");
+    await (0, import_promises2.writeFile)(outputPath, merged, "utf-8");
     timingsMs.merge = elapsedMs(mergeStart);
     markStageDone("merge", "\uBCD1\uD569 \uC644\uB8CC");
     logStage("info", "merge", "done", "\uCD5C\uC885 \uBCD1\uD569 \uC644\uB8CC", { outputPath, elapsedMs: timingsMs.merge });
@@ -12186,7 +11986,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       timingsMs,
       modelCachePath
     };
-    await (0, import_promises4.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf-8");
+    await (0, import_promises2.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf-8");
     logStage("info", "finalize", "done", "run-report \uC800\uC7A5 \uC644\uB8CC", { reportPath });
     return { outputPath, reportPath, selectedModel };
   } catch (err) {
@@ -12261,7 +12061,7 @@ async function getPdfPageCount(pdfPath) {
   return n;
 }
 async function* renderPdfToPngStream(pdfPath, prefixPath, dpi, totalPages, startPage = 1) {
-  const imagesDir = (0, import_path6.dirname)(prefixPath);
+  const imagesDir = (0, import_path5.dirname)(prefixPath);
   for (let page = startPage; page <= totalPages; page++) {
     try {
       await runCommand("pdftoppm", [
@@ -12275,9 +12075,9 @@ async function* renderPdfToPngStream(pdfPath, prefixPath, dpi, totalPages, start
         pdfPath,
         prefixPath
       ]);
-      const files = await (0, import_promises4.readdir)(imagesDir);
+      const files = await (0, import_promises2.readdir)(imagesDir);
       const pageFiles = files.filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
-      const imagePath = (0, import_path6.join)(imagesDir, pageFiles[pageFiles.length - 1]);
+      const imagePath = (0, import_path5.join)(imagesDir, pageFiles[pageFiles.length - 1]);
       yield { pageNumber: page, imagePath };
     } catch (err) {
       yield {
@@ -12290,7 +12090,7 @@ async function* renderPdfToPngStream(pdfPath, prefixPath, dpi, totalPages, start
 }
 async function runCommand(cmd, args) {
   await new Promise((resolvePromise, reject) => {
-    const child = (0, import_child_process5.spawn)(cmd, args, { stdio: "pipe" });
+    const child = (0, import_child_process4.spawn)(cmd, args, { stdio: "pipe" });
     let stderr = "";
     child.stderr.on("data", (d) => {
       stderr += String(d);
@@ -12304,7 +12104,7 @@ async function runCommand(cmd, args) {
 }
 async function runCommandWithStdout(cmd, args) {
   return await new Promise((resolvePromise, reject) => {
-    const child = (0, import_child_process5.spawn)(cmd, args, { stdio: "pipe" });
+    const child = (0, import_child_process4.spawn)(cmd, args, { stdio: "pipe" });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (d) => {
@@ -12320,6 +12120,32 @@ async function runCommandWithStdout(cmd, args) {
     });
   });
 }
+async function parseNativeDocument(buffer) {
+  const arrayBuffer = toArrayBuffer(buffer);
+  const format = detectFormat(arrayBuffer);
+  let result;
+  let fileType;
+  if (format === "hwp") {
+    result = parseHwp5Document(buffer);
+    fileType = "hwp";
+  } else if (format === "hwpx") {
+    const { format: zipFormat, zip } = await detectZipFormat(arrayBuffer);
+    if (zipFormat === "xlsx") {
+      result = await parseXlsxDocument(arrayBuffer, void 0, zip ?? void 0);
+      fileType = "xlsx";
+    } else if (zipFormat === "docx") {
+      result = await parseDocxDocument(arrayBuffer, void 0, zip ?? void 0);
+      fileType = "docx";
+    } else {
+      result = await parseHwpxDocument(arrayBuffer, void 0, zip ?? void 0);
+      fileType = "hwpx";
+    }
+  } else {
+    throw new UnifiedOcrError("UNSUPPORTED_INPUT", "convert", `\uC790\uCCB4 \uD30C\uC11C\uB85C \uCC98\uB9AC\uD560 \uC218 \uC5C6\uB294 \uC785\uB825 \uD3EC\uB9F7: ${format}`);
+  }
+  const pageCount = result.metadata?.pageCount ?? Math.max(1, ...result.blocks.map((block) => block.pageNumber ?? 1));
+  return { markdown: result.markdown, fileType, pageCount };
+}
 function naturalPageSort(a, b) {
   const na = Number((a.match(/\d+/g) || ["0"]).at(-1) || 0);
   const nb = Number((b.match(/\d+/g) || ["0"]).at(-1) || 0);
@@ -12393,7 +12219,7 @@ function startParallelProbeRuns(input) {
 }
 async function loadModelCache(path) {
   try {
-    const raw = await (0, import_promises4.readFile)(path, "utf-8");
+    const raw = await (0, import_promises2.readFile)(path, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -12424,15 +12250,15 @@ async function updateModelCache(path, probes) {
     }
   }
   current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await (0, import_promises4.writeFile)(path, JSON.stringify(current, null, 2), "utf-8");
+  await (0, import_promises2.writeFile)(path, JSON.stringify(current, null, 2), "utf-8");
 }
 async function ocrWorkerPool(input) {
-  const { queue: queue2, workerCount, ocrInput, onPageDone } = input;
+  const { queue, workerCount, ocrInput, onPageDone } = input;
   const results = /* @__PURE__ */ new Map();
   let completedCount = 0;
   async function worker() {
     while (true) {
-      const item = await queue2.dequeue();
+      const item = await queue.dequeue();
       if (item === QUEUE_DONE) break;
       const { pageNumber, imagePath, error } = item;
       if (imagePath === null) {
@@ -12484,7 +12310,7 @@ async function ocrImageWithFallback(input) {
 async function mergeMarkdownPages(paths) {
   const out = [];
   for (let i = 0; i < paths.length; i++) {
-    const txt = (await (0, import_promises4.readFile)(paths[i], "utf-8")).trim();
+    const txt = (await (0, import_promises2.readFile)(paths[i], "utf-8")).trim();
     if (!txt) continue;
     out.push(txt);
   }
@@ -12600,7 +12426,7 @@ async function ocrImageViaNim(input) {
   throw new UnifiedOcrError("OCR_FAILED", "ocr", `OCR \uC7AC\uC2DC\uB3C4 \uCD08\uACFC: ${lastErr}`);
 }
 async function encodeBase64(path) {
-  const b = await (0, import_promises4.readFile)(path);
+  const b = await (0, import_promises2.readFile)(path);
   return b.toString("base64");
 }
 function stripCodeFence3(text) {
@@ -12612,7 +12438,7 @@ async function delay(ms) {
   await new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
 }
 function ensureSupportedInput(path) {
-  const ext = (0, import_path6.extname)(path).toLowerCase();
+  const ext = (0, import_path5.extname)(path).toLowerCase();
   const allowed = /* @__PURE__ */ new Set([".pdf", ".hwp", ".hwpx", ".docx", ".xlsx"]);
   if (!allowed.has(ext)) {
     throw new UnifiedOcrError("UNSUPPORTED_INPUT", "convert", `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uC785\uB825 \uD3EC\uB9F7: ${ext}`);
@@ -12620,16 +12446,6 @@ function ensureSupportedInput(path) {
 }
 function normalizePipelineError(err, stage) {
   if (err instanceof UnifiedOcrError) return err;
-  if (err instanceof ConvertError) {
-    const codeMap = {
-      SOFFICE_NOT_FOUND: "SOFFICE_NOT_FOUND",
-      CONVERT_FAILED: "CONVERT_FAILED",
-      TIMEOUT: "CONVERT_FAILED",
-      UNSUPPORTED_PLATFORM: "CONVERT_FAILED",
-      UNSUPPORTED_FORMAT: "UNSUPPORTED_INPUT"
-    };
-    return new UnifiedOcrError(codeMap[err.code] ?? "CONVERT_FAILED", stage, err.message);
-  }
   const message = err instanceof Error ? err.message : String(err);
   const codeByStage = {
     convert: "CONVERT_FAILED",
@@ -12649,7 +12465,7 @@ async function parse2(input, options) {
   let buffer;
   if (typeof input === "string") {
     try {
-      const buf = await (0, import_promises5.readFile)(input);
+      const buf = await (0, import_promises3.readFile)(input);
       buffer = toArrayBuffer(buf);
     } catch (err) {
       const msg = err instanceof Error && "code" in err && err.code === "ENOENT" ? `\uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${input}` : `\uD30C\uC77C \uC77D\uAE30 \uC2E4\uD328: ${input}`;
@@ -12809,9 +12625,6 @@ async function parseDocx(buffer, options, zip) {
   VERSION,
   blocksToMarkdown,
   compare,
-  convertHwpToPdf,
-  convertHwpxToPdf,
-  convertToPdf,
   detectFormat,
   detectZipFormat,
   diffBlocks,