@clazic/kordoc 2.3.0 → 2.3.2

package/dist/index.js

@@ -1998,8 +1998,8 @@ function getTesseractFallbackMessage() {
     "\uC124\uCE58\uB41C AI CLI\uAC00 \uC5C6\uC5B4 \uB0B4\uC7A5 tesseract.js\uB85C OCR\uC744 \uC218\uD589\uD569\uB2C8\uB2E4.",
     "\uB354 \uB098\uC740 \uD488\uC9C8(\uD14C\uC774\uBE14/\uD5E4\uB529 \uAD6C\uC870 \uBCF4\uC874)\uC744 \uC704\uD574 AI CLI \uC124\uCE58\uB97C \uAD8C\uC7A5\uD569\uB2C8\uB2E4:",
     "",
-    "  [\uAD8C\uC7A5] Gemini CLI:  https://ai.google.dev/gemini-api/docs/cli",
-    "         Codex CLI:   npm install -g @openai/codex",
+    "  [\uAD8C\uC7A5] Codex CLI:   npm install -g @openai/codex",
+    "         Gemini CLI:  https://ai.google.dev/gemini-api/docs/cli",
     "         Claude CLI:  npm install -g @anthropic-ai/claude-code",
     "         Ollama:      brew install ollama (+ ollama pull gemma4:27b)"
   ].join("\n");
@@ -2008,7 +2008,7 @@ var CLI_PRIORITY;
 var init_auto_detect = __esm({
   "src/ocr/auto-detect.ts"() {
     "use strict";
-    CLI_PRIORITY = ["gemini", "codex", "claude", "ollama"];
+    CLI_PRIORITY = ["codex", "gemini", "claude", "ollama"];
   }
 });
 
@@ -2051,7 +2051,7 @@ function callCli(mode, imagePath) {
   const args = buildCliArgs(mode, imagePath);
   const result = spawnSync(mode, args, {
     encoding: "utf-8",
-    timeout: 18e4,
+    timeout: 6e5,
     maxBuffer: 10 * 1024 * 1024,
     // claude: /tmp에서 실행하여 프로젝트 CLAUDE.md의 규칙 간섭 방지
     ...mode === "claude" ? { cwd: tmpdir() } : {}
@@ -2145,14 +2145,22 @@ async function callOllamaApi(imagePath) {
   return data.message?.content || "";
 }
 function stripCodeFence(text) {
-  const match = text.match(/^```(?:markdown|md)?\s*\n([\s\S]*?)\n```\s*$/m);
+  const match = text.match(/^```(?:markdown|md)?\s*([\s\S]*?)```\s*$/m);
   return match ? match[1].trim() : text;
 }
 var OCR_PROMPT, _tempDir;
 var init_cli_provider = __esm({
   "src/ocr/cli-provider.ts"() {
     "use strict";
-    OCR_PROMPT = "\uC774 PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0\uC5D0\uC11C \uD14D\uC2A4\uD2B8\uC640 \uD14C\uC774\uBE14\uC744 \uCD94\uCD9C\uD558\uC5EC \uC21C\uC218 Markdown\uC73C\uB85C \uBCC0\uD658\uD558\uC138\uC694.\n\uADDC\uCE59:\n- \uD14C\uC774\uBE14\uC740 Markdown \uD14C\uC774\uBE14 \uBB38\uBC95 \uC0AC\uC6A9 (| \uAD6C\uBD84, |---|---| \uD5E4\uB354 \uAD6C\uBD84\uC120 \uD3EC\uD568)\n- \uBCD1\uD569\uB41C \uC140\uC740 \uD574\uB2F9 \uC704\uCE58\uC5D0 \uB0B4\uC6A9 \uAE30\uC7AC\n- \uD5E4\uB529\uC740 \uAE00\uC790 \uD06C\uAE30\uC5D0 \uB530\uB77C ## ~ ###### \uC0AC\uC6A9\n- \uB9AC\uC2A4\uD2B8\uB294 - \uB610\uB294 1. \uC0AC\uC6A9\n- \uC774\uBBF8\uC9C0, \uB3C4\uD615 \uB4F1 \uBE44\uD14D\uC2A4\uD2B8 \uC694\uC18C\uB294 \uBB34\uC2DC\n- \uC6D0\uBB38\uC758 \uC77D\uAE30 \uC21C\uC11C\uC640 \uAD6C\uC870\uB97C \uC720\uC9C0\n- ```\uB85C \uAC10\uC2F8\uC9C0 \uB9D0\uACE0 \uC21C\uC218 Markdown\uB9CC \uCD9C\uB825";
+    OCR_PROMPT = `\uC774 PDF \uD398\uC774\uC9C0 \uC774\uBBF8\uC9C0\uC5D0\uC11C \uD14D\uC2A4\uD2B8\uC640 \uD14C\uC774\uBE14\uC744 \uCD94\uCD9C\uD558\uC5EC \uC21C\uC218 Markdown\uC73C\uB85C \uBCC0\uD658\uD558\uC138\uC694.
+\uADDC\uCE59:
+- \uD14C\uC774\uBE14\uC740 Markdown \uD14C\uC774\uBE14 \uBB38\uBC95 \uC0AC\uC6A9 (| \uAD6C\uBD84, |---|---| \uD5E4\uB354 \uAD6C\uBD84\uC120 \uD3EC\uD568)
+- \uBCD1\uD569\uB41C \uC140\uC740 \uD574\uB2F9 \uC704\uCE58\uC5D0 \uB0B4\uC6A9 \uAE30\uC7AC
+- \uD5E4\uB529\uC740 \uAE00\uC790 \uD06C\uAE30\uC5D0 \uB530\uB77C ## ~ ###### \uC0AC\uC6A9
+- \uB9AC\uC2A4\uD2B8\uB294 - \uB610\uB294 1. \uC0AC\uC6A9
+- \uC774\uBBF8\uC9C0, \uB3C4\uD615 \uB4F1 \uBE44\uD14D\uC2A4\uD2B8 \uC694\uC18C\uB294 \uBB34\uC2DC
+- \uC6D0\uBB38\uC758 \uC77D\uAE30 \uC21C\uC11C\uC640 \uAD6C\uC870\uB97C \uC720\uC9C0
+- \`\`\`\uB85C \uAC10\uC2F8\uC9C0 \uB9D0\uACE0 \uC21C\uC218 Markdown\uB9CC \uCD9C\uB825`;
     _tempDir = null;
   }
 });
@@ -2222,7 +2230,7 @@ __export(batch_provider_exports, {
   DEFAULT_BATCH_SIZES: () => DEFAULT_BATCH_SIZES,
   createBatchCliProvider: () => createBatchCliProvider
 });
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawn } from "child_process";
 import { writeFileSync as writeFileSync2, readFileSync as readFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2 } from "fs";
 import { join as join2 } from "path";
 import { tmpdir as tmpdir2 } from "os";
@@ -2249,9 +2257,9 @@ function createBatchCliProvider(mode, batchSize) {
         }
         let output;
         if (mode === "codex") {
-          output = callBatchCodexCli(tempFiles);
+          output = await callBatchCodexCli(tempFiles);
         } else {
-          output = callBatchCli(mode, tempFiles);
+          output = await callBatchCli(mode, tempFiles);
         }
         const cleaned = stripCodeFence2(output.trim());
         const parts = cleaned.split(/<!--\s*PAGE_BREAK\s*-->/).map((p) => p.trim()).filter((p) => p.length > 0);
@@ -2273,40 +2281,74 @@ function createBatchCliProvider(mode, batchSize) {
     }
   };
 }
-function callBatchCli(mode, imagePaths) {
+function spawnAsync(cmd, args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      cwd: opts.cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let killed = false;
+    child.stdout.setEncoding("utf-8");
+    child.stderr.setEncoding("utf-8");
+    child.stdout.on("data", (d) => {
+      stdout += d;
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d;
+    });
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+    }, opts.timeoutMs);
+    if (opts.stdin !== void 0) {
+      child.stdin.end(opts.stdin);
+    } else {
+      child.stdin.end();
+    }
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (killed) {
+        reject(new Error(`\uD0C0\uC784\uC544\uC6C3 (${Math.round(opts.timeoutMs / 1e3)}\uCD08)`));
+      } else {
+        resolve({ stdout, stderr, exitCode: code ?? 1 });
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+async function callBatchCli(mode, imagePaths) {
   const fileRefs = imagePaths.map((p) => `@${p}`).join("\n");
   const prompt = `${BATCH_OCR_PROMPT}
 
 ${fileRefs}`;
   let args;
   if (mode === "gemini") {
-    args = ["--prompt", prompt, "--yolo"];
-    const model = process.env.KORDOC_GEMINI_MODEL;
-    if (model) args.push("--model", model);
+    const model = process.env.KORDOC_GEMINI_MODEL ?? "gemini-2.5-flash";
+    args = ["--prompt", prompt, "--yolo", "--model", model];
   } else {
     args = ["--print", prompt];
     const model = process.env.KORDOC_CLAUDE_MODEL;
     if (model) args.push("--model", model);
   }
   const timeoutMs = 6e4 + imagePaths.length * 2e4;
-  const result = spawnSync2(mode, args, {
-    encoding: "utf-8",
-    timeout: timeoutMs,
-    maxBuffer: 50 * 1024 * 1024,
-    // 50MB (large batch output)
+  const result = await spawnAsync(mode, args, {
+    timeoutMs,
     ...mode === "claude" ? { cwd: tmpdir2() } : {}
   });
-  if (result.error) {
-    throw new Error(`${mode} \uBC30\uCE58 OCR \uC2E4\uD328: ${result.error.message}`);
-  }
-  if (result.status !== 0) {
-    const errMsg = result.stderr?.trim() || `exit code ${result.status}`;
+  if (result.exitCode !== 0) {
+    const errMsg = result.stderr?.trim() || `exit code ${result.exitCode}`;
     throw new Error(`${mode} \uBC30\uCE58 OCR \uC2E4\uD328: ${errMsg}`);
   }
   return result.stdout || "";
 }
-function callBatchCodexCli(imagePaths) {
-  const outPath = join2(tmpdir2(), `kordoc-codex-batch-${Date.now()}.txt`);
+async function callBatchCodexCli(imagePaths) {
+  const outPath = join2(tmpdir2(), `kordoc-codex-batch-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
   try {
     const args = ["exec", BATCH_OCR_PROMPT];
     for (const p of imagePaths) {
@@ -2316,17 +2358,12 @@ function callBatchCodexCli(imagePaths) {
     const model = process.env.KORDOC_CODEX_MODEL;
     if (model) args.push("--model", model);
     const timeoutMs = 6e4 + imagePaths.length * 2e4;
-    const result = spawnSync2("codex", args, {
-      encoding: "utf-8",
-      timeout: timeoutMs,
-      maxBuffer: 50 * 1024 * 1024,
-      input: ""
+    const result = await spawnAsync("codex", args, {
+      timeoutMs,
+      stdin: ""
     });
-    if (result.error) {
-      throw new Error(`codex \uBC30\uCE58 OCR \uC2E4\uD328: ${result.error.message}`);
-    }
-    if (result.status !== 0) {
-      const errMsg = result.stderr?.trim() || `exit code ${result.status}`;
+    if (result.exitCode !== 0) {
+      const errMsg = result.stderr?.trim() || `exit code ${result.exitCode}`;
       throw new Error(`codex \uBC30\uCE58 OCR \uC2E4\uD328: ${errMsg}`);
     }
     try {
@@ -2584,7 +2621,7 @@ function isBatchProvider(p) {
 async function ocrPages(doc, provider, pageFilter, effectivePageCount, warnings, concurrency = 1, onProgress) {
   const blocks = [];
   if (isBatchProvider(provider)) {
-    return ocrPagesBatch(doc, provider, pageFilter, effectivePageCount, warnings, onProgress);
+    return ocrPagesBatch(doc, provider, pageFilter, effectivePageCount, warnings, concurrency, onProgress);
   }
   if (concurrency <= 1) {
     for (let i = 1; i <= effectivePageCount; i++) {
@@ -2631,43 +2668,54 @@ async function ocrPages(doc, provider, pageFilter, effectivePageCount, warnings,
   }
   return blocks;
 }
-async function ocrPagesBatch(doc, provider, pageFilter, effectivePageCount, warnings, onProgress) {
-  const blocks = [];
+async function ocrPagesBatch(doc, provider, pageFilter, effectivePageCount, warnings, concurrency = 1, onProgress) {
   const pageNumbers = [];
   for (let i = 1; i <= effectivePageCount; i++) {
     if (pageFilter && !pageFilter.has(i)) continue;
     pageNumbers.push(i);
   }
-  const pageImages = [];
-  for (const pageNum of pageNumbers) {
-    const page = await doc.getPage(pageNum);
-    const image = await renderPageToPng(page);
-    pageImages.push({ image, pageNum });
-  }
-  const batches = [];
-  for (let i = 0; i < pageImages.length; i += provider.batchSize) {
-    batches.push(pageImages.slice(i, i + provider.batchSize));
+  const pageBatches = [];
+  for (let i = 0; i < pageNumbers.length; i += provider.batchSize) {
+    pageBatches.push(pageNumbers.slice(i, i + provider.batchSize));
   }
   let processed = 0;
-  for (const batch of batches) {
+  const batchTasks = pageBatches.map((batchPageNums, batchIdx) => async () => {
+    const pageBlocks = [];
     try {
-      const results = await provider.processBatch(batch);
-      for (const { pageNum } of batch) {
+      const batchImages = [];
+      for (const pageNum of batchPageNums) {
+        const page = await doc.getPage(pageNum);
+        const image = await renderPageToPng(page);
+        batchImages.push({ image, pageNum });
+      }
+      const results = await provider.processBatch(batchImages);
+      for (const { pageNum } of batchImages) {
         const result = results.get(pageNum);
-        if (result) {
-          for (const b of ocrResultToBlocks(result, pageNum)) blocks.push(b);
-        }
-        processed++;
-        onProgress?.(processed, pageNumbers.length);
+        pageBlocks.push({
+          pageNum,
+          blocks: result ? ocrResultToBlocks(result, pageNum) : []
+        });
       }
     } catch (err) {
-      const range = `${batch[0].pageNum}-${batch[batch.length - 1].pageNum}`;
+      const range = `${batchPageNums[0]}-${batchPageNums[batchPageNums.length - 1]}`;
       warnings?.push({
         message: `\uBC30\uCE58 OCR \uC2E4\uD328 (\uD398\uC774\uC9C0 ${range}): ${err instanceof Error ? err.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`,
         code: "OCR_PAGE_FAILED"
       });
-      processed += batch.length;
-      onProgress?.(processed, pageNumbers.length);
+      for (const pageNum of batchPageNums) {
+        pageBlocks.push({ pageNum, blocks: [] });
+      }
+    }
+    processed += batchPageNums.length;
+    onProgress?.(processed, pageNumbers.length);
+    return { batchIdx, pageBlocks };
+  });
+  const effectiveConcurrency = Math.max(1, concurrency);
+  const batchResults = await runWithConcurrency(batchTasks, effectiveConcurrency);
+  const blocks = [];
+  for (const result of batchResults) {
+    for (const { blocks: pageBlks } of result.pageBlocks) {
+      for (const b of pageBlks) blocks.push(b);
     }
   }
   return blocks;
@@ -2711,24 +2759,29 @@ function isPdfFile(buffer) {
   const b = magicBytes(buffer);
   return b[0] === 37 && b[1] === 80 && b[2] === 68 && b[3] === 70;
 }
+function isPngFile(buffer) {
+  const b = magicBytes(buffer);
+  return b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71;
+}
 function detectFormat(buffer) {
   if (buffer.byteLength < 4) return "unknown";
   if (isZipFile(buffer)) return "hwpx";
   if (isOldHwpFile(buffer)) return "hwp";
   if (isPdfFile(buffer)) return "pdf";
+  if (isPngFile(buffer)) return "image";
   return "unknown";
 }
 async function detectZipFormat(buffer) {
   try {
     const zip = await JSZip.loadAsync(buffer);
-    if (zip.file("xl/workbook.xml")) return "xlsx";
-    if (zip.file("word/document.xml")) return "docx";
-    if (zip.file("Contents/content.hpf") || zip.file("mimetype")) return "hwpx";
+    if (zip.file("xl/workbook.xml")) return { format: "xlsx", zip };
+    if (zip.file("word/document.xml")) return { format: "docx", zip };
+    if (zip.file("Contents/content.hpf") || zip.file("mimetype")) return { format: "hwpx", zip };
     const hasSection = Object.keys(zip.files).some((f) => f.startsWith("Contents/"));
-    if (hasSection) return "hwpx";
-    return "unknown";
+    if (hasSection) return { format: "hwpx", zip };
+    return { format: "unknown", zip: null };
   } catch {
-    return "unknown";
+    return { format: "unknown", zip: null };
   }
 }
 
@@ -2737,7 +2790,7 @@ import JSZip2 from "jszip";
 import { DOMParser } from "@xmldom/xmldom";
 
 // src/utils.ts
-var VERSION = true ? "2.3.0" : "0.0.0-dev";
+var VERSION = true ? "2.3.2" : "0.0.0-dev";
 function toArrayBuffer(buf) {
   if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
     return buf.buffer;
@@ -2897,12 +2950,16 @@ function buildTableDirect(rows, numRows) {
   return trimAndReturn(grid, numRows, maxCols);
 }
 function trimAndReturn(grid, numRows, maxCols) {
-  let effectiveCols = maxCols;
-  while (effectiveCols > 0) {
-    const colEmpty = grid.every((row) => !row[effectiveCols - 1]?.text?.trim());
-    if (!colEmpty) break;
-    effectiveCols--;
+  let effectiveCols = 0;
+  for (const row of grid) {
+    for (let c = row.length - 1; c >= effectiveCols; c--) {
+      if (row[c]?.text?.trim()) {
+        effectiveCols = c + 1;
+        break;
+      }
+    }
   }
+  if (effectiveCols === 0) effectiveCols = maxCols;
   if (effectiveCols < maxCols && effectiveCols > 0) {
     const trimmed = grid.map((row) => row.slice(0, effectiveCols));
     return { rows: numRows, cols: effectiveCols, cells: trimmed, hasHeader: numRows > 1 };
@@ -3159,11 +3216,11 @@ function parseStyleElements(doc, map) {
 function stripDtd(xml) {
   return xml.replace(/<!DOCTYPE\s[^[>]*(\[[\s\S]*?\])?\s*>/gi, "");
 }
-async function parseHwpxDocument(buffer, options) {
+async function parseHwpxDocument(buffer, options, existingZip) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE, MAX_ZIP_ENTRIES);
   let zip;
   try {
-    zip = await JSZip2.loadAsync(buffer);
+    zip = existingZip ?? await JSZip2.loadAsync(buffer);
   } catch {
     return await extractFromBrokenZip(buffer);
   }
@@ -6175,8 +6232,15 @@ import { getDocument, GlobalWorkerOptions } from "pdfjs-dist/legacy/build/pdf.mj
 GlobalWorkerOptions.workerSrc = "";
 var MAX_PAGES = 5e3;
 var MAX_TOTAL_TEXT = 500 * 1024 * 1024;
-var PDF_LOAD_TIMEOUT_MS = 3e4;
+function calcPdfTimeout(bufferSize) {
+  const base = 3e4;
+  const perMb = 500;
+  const mb = bufferSize / (1024 * 1024);
+  return Math.min(base + Math.ceil(mb * perMb), 3e5);
+}
 async function loadPdfWithTimeout(buffer) {
+  const timeoutMs = calcPdfTimeout(buffer.byteLength);
+  const timeoutSec = Math.round(timeoutMs / 1e3);
   const loadingTask = getDocument({
     data: new Uint8Array(buffer),
     useSystemFonts: true,
@@ -6190,8 +6254,8 @@ async function loadPdfWithTimeout(buffer) {
       new Promise((_, reject) => {
         timer = setTimeout(() => {
           loadingTask.destroy();
-          reject(new KordocError("PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (30\uCD08 \uCD08\uACFC)"));
-        }, PDF_LOAD_TIMEOUT_MS);
+          reject(new KordocError(`PDF \uB85C\uB529 \uD0C0\uC784\uC544\uC6C3 (${timeoutSec}\uCD08 \uCD08\uACFC)`));
+        }, timeoutMs);
       })
     ]);
   } finally {
@@ -6212,11 +6276,15 @@ async function parsePdfDocument(buffer, options) {
     const effectivePageCount = Math.min(pageCount, MAX_PAGES);
     const pageFilter = options?.pages ? parsePageRange(options.pages, effectivePageCount) : null;
     const totalTarget = pageFilter ? pageFilter.size : effectivePageCount;
-    const allFontSizes = [];
+    const fontSizeFreq = /* @__PURE__ */ new Map();
     const pageHeights = /* @__PURE__ */ new Map();
-    let parsedPages = 0;
+    const targetPageNums = [];
     for (let i = 1; i <= effectivePageCount; i++) {
       if (pageFilter && !pageFilter.has(i)) continue;
+      targetPageNums.push(i);
+    }
+    let parsedPages = 0;
+    const parseSinglePage = async (i) => {
       try {
         const page = await doc.getPage(i);
         const tc = await page.getTextContent();
@@ -6229,7 +6297,10 @@ async function parsePdfDocument(buffer, options) {
           warnings.push({ page: i, message: `${hiddenCount}\uAC1C \uC228\uACA8\uC9C4 \uD14D\uC2A4\uD2B8 \uC694\uC18C \uD544\uD130\uB9C1\uB428`, code: "HIDDEN_TEXT_FILTERED" });
         }
         for (const item of visible) {
-          if (item.fontSize > 0) allFontSizes.push(item.fontSize);
+          if (item.fontSize > 0) {
+            const rounded = Math.round(item.fontSize * 10) / 10;
+            fontSizeFreq.set(rounded, (fontSizeFreq.get(rounded) || 0) + 1);
+          }
         }
         const opList = await page.getOperatorList();
         const pageBlocks = extractPageBlocksWithLines(visible, i, opList, viewport.width, viewport.height);
@@ -6246,12 +6317,23 @@ async function parsePdfDocument(buffer, options) {
         if (pageErr instanceof KordocError) throw pageErr;
         warnings.push({ page: i, message: `\uD398\uC774\uC9C0 ${i} \uD30C\uC2F1 \uC2E4\uD328: ${pageErr instanceof Error ? pageErr.message : "\uC54C \uC218 \uC5C6\uB294 \uC624\uB958"}`, code: "PARTIAL_PARSE" });
       }
+    };
+    const sampleCount = Math.min(5, targetPageNums.length);
+    for (let si = 0; si < sampleCount; si++) {
+      await parseSinglePage(targetPageNums[si]);
+    }
+    const sampleParsed = parsedPages || sampleCount;
+    const isImageBased = totalChars / Math.max(sampleParsed, 1) < 10;
+    if (!isImageBased) {
+      for (let si = sampleCount; si < targetPageNums.length; si++) {
+        await parseSinglePage(targetPageNums[si]);
+      }
     }
     const parsedPageCount = parsedPages || (pageFilter ? pageFilter.size : effectivePageCount);
-    if (totalChars / Math.max(parsedPageCount, 1) < 10) {
+    if (isImageBased) {
       let ocrProvider = options?.ocr ?? null;
-      const ocrMode = options?.ocrMode;
-      if (!ocrProvider && ocrMode && ocrMode !== "off") {
+      const ocrMode = options?.ocrMode ?? "auto";
+      if (!ocrProvider && ocrMode !== "off") {
         try {
           const { resolveOcrProvider: resolveOcrProvider2 } = await Promise.resolve().then(() => (init_resolve(), resolve_exports));
           const concurrency = options?.ocrConcurrency ?? 1;
@@ -6303,7 +6385,7 @@ async function parsePdfDocument(buffer, options) {
         blocks.splice(removed[ri], 1);
       }
     }
-    const medianFontSize = computeMedianFontSize(allFontSizes);
+    const medianFontSize = computeMedianFromFreq(fontSizeFreq);
     if (medianFontSize > 0) {
       detectHeadings(blocks, medianFontSize);
     }
@@ -6356,11 +6438,18 @@ function filterHiddenText(items, pageWidth, pageHeight) {
   }
   return { visible, hiddenCount };
 }
-function computeMedianFontSize(sizes) {
-  if (sizes.length === 0) return 0;
-  const sorted = [...sizes].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+function computeMedianFromFreq(freq) {
+  if (freq.size === 0) return 0;
+  const entries = [...freq.entries()].sort((a, b) => a[0] - b[0]);
+  let total = 0;
+  for (const [, count] of entries) total += count;
+  const mid = total / 2;
+  let cumulative = 0;
+  for (const [size, count] of entries) {
+    cumulative += count;
+    if (cumulative >= mid) return size;
+  }
+  return 0;
 }
 function detectHeadings(blocks, medianFontSize) {
   for (const block of blocks) {
@@ -7163,6 +7252,7 @@ var MAX_SHEETS = 100;
 var MAX_DECOMPRESS_SIZE3 = 500 * 1024 * 1024;
 var MAX_ROWS2 = 1e4;
 var MAX_COLS2 = 200;
+var MAX_TOTAL_CELLS = 2e6;
 function cleanNumericValue(raw) {
   if (!/^-?\d+\.\d+$/.test(raw)) return raw;
   const num = parseFloat(raw);
@@ -7346,9 +7436,9 @@ function sheetToBlocks(sheetName, grid, merges, maxRow, maxCol, sheetIndex) {
   }
   return blocks;
 }
-async function parseXlsxDocument(buffer, options) {
+async function parseXlsxDocument(buffer, options, existingZip) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE3);
-  const zip = await JSZip3.loadAsync(buffer);
+  const zip = existingZip ?? await JSZip3.loadAsync(buffer);
   const warnings = [];
   const workbookFile = zip.file("xl/workbook.xml");
   if (!workbookFile) {
@@ -7375,6 +7465,7 @@ async function parseXlsxDocument(buffer, options) {
   }
   const blocks = [];
   const processedSheets = Math.min(sheets.length, MAX_SHEETS);
+  let totalCells = 0;
   for (let i = 0; i < processedSheets; i++) {
     if (pageFilter && !pageFilter.has(i + 1)) continue;
     const sheet = sheets[i];
@@ -7401,6 +7492,11 @@ async function parseXlsxDocument(buffer, options) {
     try {
       const sheetXml = await sheetFile.async("text");
       const { grid, merges, maxRow, maxCol } = parseWorksheet(sheetXml, sharedStrings);
+      totalCells += maxRow * maxCol;
+      if (totalCells > MAX_TOTAL_CELLS) {
+        warnings.push({ message: `\uCD1D \uC140 \uC218 \uC81C\uD55C \uCD08\uACFC (${totalCells.toLocaleString()}\uC140), \uC774\uD6C4 \uC2DC\uD2B8 \uC0DD\uB7B5`, code: "PARTIAL_PARSE" });
+        break;
+      }
       const sheetBlocks = sheetToBlocks(sheet.name, grid, merges, maxRow, maxCol, i);
       blocks.push(...sheetBlocks);
     } catch (err) {
@@ -7484,10 +7580,35 @@ function getAttr(el, localName) {
 function parseXml2(text) {
   return new DOMParser3().parseFromString(text, "text/xml");
 }
+function buildElementIndex(root) {
+  const index = /* @__PURE__ */ new Map();
+  const walk = (node) => {
+    const children = node.childNodes;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.nodeType === 1) {
+        const el = child;
+        const name = el.localName ?? "";
+        if (name) {
+          let list = index.get(name);
+          if (!list) {
+            list = [];
+            index.set(name, list);
+          }
+          list.push(el);
+        }
+        walk(el);
+      }
+    }
+  };
+  walk(root);
+  return index;
+}
 function parseStyles(xml) {
   const doc = parseXml2(xml);
   const styles = /* @__PURE__ */ new Map();
-  const styleElements = findElements(doc, "style");
+  const idx = buildElementIndex(doc);
+  const styleElements = idx.get("style") ?? [];
   for (const el of styleElements) {
     const styleId = getAttr(el, "styleId");
     if (!styleId) continue;
@@ -7515,7 +7636,8 @@ function parseStyles(xml) {
 function parseNumbering(xml) {
   const doc = parseXml2(xml);
   const abstractNums = /* @__PURE__ */ new Map();
-  const abstractElements = findElements(doc, "abstractNum");
+  const idx = buildElementIndex(doc);
+  const abstractElements = idx.get("abstractNum") ?? [];
   for (const el of abstractElements) {
     const abstractNumId = getAttr(el, "abstractNumId");
     if (!abstractNumId) continue;
@@ -7530,7 +7652,7 @@ function parseNumbering(xml) {
     abstractNums.set(abstractNumId, levels);
   }
   const nums = /* @__PURE__ */ new Map();
-  const numElements = findElements(doc, "num");
+  const numElements = idx.get("num") ?? [];
   for (const el of numElements) {
     const numId = getAttr(el, "numId");
     if (!numId) continue;
@@ -7774,9 +7896,9 @@ async function extractImages(zip, rels, doc) {
   }
   return { blocks, images };
 }
-async function parseDocxDocument(buffer, options) {
+async function parseDocxDocument(buffer, options, existingZip) {
   precheckZipSize(buffer, MAX_DECOMPRESS_SIZE4);
-  const zip = await JSZip4.loadAsync(buffer);
+  const zip = existingZip ?? await JSZip4.loadAsync(buffer);
   const warnings = [];
   const docFile = zip.file("word/document.xml");
   if (!docFile) {
@@ -7866,6 +7988,11 @@ async function parseDocxDocument(buffer, options) {
   };
 }
 
+// src/index.ts
+init_cli_provider();
+init_tesseract_provider();
+init_markdown_to_blocks();
+
 // src/diff/text-diff.ts
 function similarity(a, b) {
   if (a === b) return 1;
@@ -10382,25 +10509,86 @@ async function parse2(input, options) {
   if (!buffer || buffer.byteLength === 0) {
     return { success: false, fileType: "unknown", error: "\uBE48 \uBC84\uD37C\uC774\uAC70\uB098 \uC720\uD6A8\uD558\uC9C0 \uC54A\uC740 \uC785\uB825\uC785\uB2C8\uB2E4.", code: "EMPTY_INPUT" };
   }
+  const MAX_FILE_SIZE = 500 * 1024 * 1024;
+  if (buffer.byteLength > MAX_FILE_SIZE) {
+    return { success: false, fileType: "unknown", error: `\uD30C\uC77C \uD06C\uAE30 \uCD08\uACFC: ${(buffer.byteLength / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 500MB)`, code: "FILE_TOO_LARGE" };
+  }
   const format = detectFormat(buffer);
   switch (format) {
     case "hwpx": {
-      const zipFormat = await detectZipFormat(buffer);
-      if (zipFormat === "xlsx") return parseXlsx(buffer, options);
-      if (zipFormat === "docx") return parseDocx(buffer, options);
-      return parseHwpx(buffer, options);
+      const { format: zipFormat, zip } = await detectZipFormat(buffer);
+      if (zipFormat === "xlsx") return parseXlsx(buffer, options, zip ?? void 0);
+      if (zipFormat === "docx") return parseDocx(buffer, options, zip ?? void 0);
+      return parseHwpx(buffer, options, zip ?? void 0);
     }
     case "hwp":
       return parseHwp(buffer, options);
     case "pdf":
       return parsePdf(buffer, options);
+    case "image":
+      return parseImage(buffer, options);
     default:
       return { success: false, fileType: "unknown", error: "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD30C\uC77C \uD615\uC2DD\uC785\uB2C8\uB2E4.", code: "UNSUPPORTED_FORMAT" };
   }
 }
-async function parseHwpx(buffer, options) {
+async function parseImage(buffer, options) {
+  const ocrMode = options?.ocrMode || "auto";
+  if (ocrMode === "off") {
+    return { success: false, fileType: "image", error: "OCR\uC774 \uBE44\uD65C\uC131\uD654\uB418\uC5B4 \uC774\uBBF8\uC9C0 \uD30C\uC77C\uC744 \uCC98\uB9AC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", code: "IMAGE_BASED_PDF" };
+  }
+  let ocrProvider;
+  let actualOcrMode = "auto";
+  try {
+    if (ocrMode === "gemini" || ocrMode === "claude" || ocrMode === "codex" || ocrMode === "ollama") {
+      ocrProvider = createCliOcrProvider(ocrMode);
+      actualOcrMode = ocrMode;
+    } else if (ocrMode === "tesseract") {
+      ocrProvider = await createTesseractProvider();
+      actualOcrMode = ocrMode;
+    } else if (ocrMode === "auto") {
+      const modesToTry = ["gemini", "claude", "codex", "ollama"];
+      for (const mode of modesToTry) {
+        try {
+          ocrProvider = createCliOcrProvider(mode);
+          actualOcrMode = mode;
+          break;
+        } catch (e) {
+          console.warn(`[kordoc] OCR auto-detection: ${mode} CLI not available or failed. Trying next.`, e);
+        }
+      }
+      if (!ocrProvider) {
+        ocrProvider = await createTesseractProvider();
+        actualOcrMode = "tesseract";
+      }
+    }
+    if (!ocrProvider) {
+      return { success: false, fileType: "image", error: "\uC0AC\uC6A9 \uAC00\uB2A5\uD55C OCR \uD504\uB85C\uBC14\uC774\uB354\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.", code: "PARSE_ERROR" };
+    }
+    const imageUint8Array = new Uint8Array(buffer);
+    const ocrResult = await ocrProvider(imageUint8Array, 1, "image/png");
+    if (ocrProvider.terminate) {
+      await ocrProvider.terminate();
+    }
+    const markdown = typeof ocrResult === "string" ? ocrResult : ocrResult.markdown;
+    const blocks = markdownToBlocks(markdown, 1);
+    return {
+      success: true,
+      fileType: "image",
+      markdown,
+      blocks,
+      isImageBased: true,
+      warnings: [{ message: `OCR \uCC98\uB9AC\uB428 (${actualOcrMode})`, code: "OCR_FALLBACK" }]
+    };
+  } catch (err) {
+    if (ocrProvider && ocrProvider.terminate) {
+      await ocrProvider.terminate();
+    }
+    return { success: false, fileType: "image", error: err instanceof Error ? err.message : "\uC774\uBBF8\uC9C0 OCR \uC2E4\uD328", code: classifyError(err) };
+  }
+}
+async function parseHwpx(buffer, options, zip) {
   try {
-    const { markdown, blocks, metadata, outline, warnings, images } = await parseHwpxDocument(buffer, options);
+    const { markdown, blocks, metadata, outline, warnings, images } = await parseHwpxDocument(buffer, options, zip);
     return { success: true, fileType: "hwpx", markdown, blocks, metadata, outline, warnings, images: images?.length ? images : void 0 };
   } catch (err) {
     return { success: false, fileType: "hwpx", error: err instanceof Error ? err.message : "HWPX \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
@@ -10423,17 +10611,17 @@ async function parsePdf(buffer, options) {
     return { success: false, fileType: "pdf", error: err instanceof Error ? err.message : "PDF \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err), isImageBased };
   }
 }
-async function parseXlsx(buffer, options) {
+async function parseXlsx(buffer, options, zip) {
   try {
-    const { markdown, blocks, metadata, warnings } = await parseXlsxDocument(buffer, options);
+    const { markdown, blocks, metadata, warnings } = await parseXlsxDocument(buffer, options, zip);
     return { success: true, fileType: "xlsx", markdown, blocks, metadata, warnings };
   } catch (err) {
     return { success: false, fileType: "xlsx", error: err instanceof Error ? err.message : "XLSX \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };
   }
 }
-async function parseDocx(buffer, options) {
+async function parseDocx(buffer, options, zip) {
   try {
-    const { markdown, blocks, metadata, outline, warnings, images } = await parseDocxDocument(buffer, options);
+    const { markdown, blocks, metadata, outline, warnings, images } = await parseDocxDocument(buffer, options, zip);
     return { success: true, fileType: "docx", markdown, blocks, metadata, outline, warnings, images: images?.length ? images : void 0 };
   } catch (err) {
     return { success: false, fileType: "docx", error: err instanceof Error ? err.message : "DOCX \uD30C\uC2F1 \uC2E4\uD328", code: classifyError(err) };