@clazic/kordoc 2.6.0 → 2.7.0

package/dist/index.js

@@ -37,118 +37,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  KordocError: () => KordocError,
-  VERSION: () => VERSION,
-  classifyError: () => classifyError,
-  isPathTraversal: () => isPathTraversal,
-  normalizeKordocError: () => normalizeKordocError,
-  precheckZipSize: () => precheckZipSize,
-  sanitizeError: () => sanitizeError,
-  sanitizeHref: () => sanitizeHref,
-  toArrayBuffer: () => toArrayBuffer
-});
-function toArrayBuffer(buf) {
-  if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
-    return buf.buffer;
-  }
-  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-}
-function sanitizeError(err) {
-  if (err instanceof KordocError) return err.message;
-  return "\uBB38\uC11C \uCC98\uB9AC \uC911 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4";
-}
-function isPathTraversal(name) {
-  if (name.includes("\0")) return true;
-  const normalized = name.replace(/\\/g, "/");
-  return normalized.includes("..") || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized);
-}
-function precheckZipSize(buffer, maxUncompressedSize = 100 * 1024 * 1024, maxEntries = 500) {
-  try {
-    const data = new DataView(buffer);
-    const len = buffer.byteLength;
-    let eocdOffset = -1;
-    for (let i = len - 22; i >= Math.max(0, len - 65557); i--) {
-      if (data.getUint32(i, true) === 101010256) {
-        eocdOffset = i;
-        break;
-      }
-    }
-    if (eocdOffset < 0) return { totalUncompressed: 0, entryCount: 0 };
-    const entryCount = data.getUint16(eocdOffset + 10, true);
-    if (entryCount > maxEntries) {
-      throw new KordocError(`ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC: ${entryCount} (\uCD5C\uB300 ${maxEntries})`);
-    }
-    const cdSize = data.getUint32(eocdOffset + 12, true);
-    const cdOffset = data.getUint32(eocdOffset + 16, true);
-    if (cdOffset + cdSize > len) return { totalUncompressed: 0, entryCount };
-    let totalUncompressed = 0;
-    let pos = cdOffset;
-    for (let i = 0; i < entryCount && pos + 46 <= cdOffset + cdSize; i++) {
-      if (data.getUint32(pos, true) !== 33639248) break;
-      totalUncompressed += data.getUint32(pos + 24, true);
-      const nameLen = data.getUint16(pos + 28, true);
-      const extraLen = data.getUint16(pos + 30, true);
-      const commentLen = data.getUint16(pos + 32, true);
-      pos += 46 + nameLen + extraLen + commentLen;
-    }
-    if (totalUncompressed > maxUncompressedSize) {
-      throw new KordocError(`ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC: ${(totalUncompressed / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 ${maxUncompressedSize / 1024 / 1024}MB)`);
-    }
-    return { totalUncompressed, entryCount };
-  } catch (err) {
-    if (err instanceof KordocError) throw err;
-    return { totalUncompressed: 0, entryCount: 0 };
-  }
-}
-function sanitizeHref(href) {
-  const trimmed = href.trim();
-  if (!trimmed || !SAFE_HREF_RE.test(trimmed)) return null;
-  return trimmed;
-}
-function classifyError(err) {
-  if (!(err instanceof Error)) return "PARSE_ERROR";
-  const msg = err.message;
-  if (msg.includes("\uC554\uD638\uD654")) return "ENCRYPTED";
-  if (msg.includes("DRM")) return "DRM_PROTECTED";
-  if (msg.includes("ZIP bomb") || msg.includes("ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC") || msg.includes("ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC")) return "ZIP_BOMB";
-  if (msg.includes("bomb") || msg.includes("\uD06C\uAE30 \uCD08\uACFC") || msg.includes("\uC555\uCD95 \uD574\uC81C")) return "DECOMPRESSION_BOMB";
-  if (msg.includes("\uC774\uBBF8\uC9C0 \uAE30\uBC18")) return "IMAGE_BASED_PDF";
-  if (msg.includes("\uC139\uC158") && (msg.includes("\uCC3E\uC744 \uC218 \uC5C6") || msg.includes("\uC5C6\uC74C"))) return "NO_SECTIONS";
-  if (msg.includes("\uC2DC\uADF8\uB2C8\uCC98") || msg.includes("\uBCF5\uAD6C\uD560 \uC218 \uC5C6")) return "CORRUPTED";
-  return "PARSE_ERROR";
-}
-function normalizeKordocError(err, fallbackMessage, stage = "unknown", fallbackCode = "PARSE_ERROR") {
-  if (err instanceof KordocError) {
-    if (!err.stage) err.stage = stage;
-    if (!err.code) err.code = fallbackCode;
-    return err;
-  }
-  const message = err instanceof Error ? err.message : fallbackMessage;
-  const code = err instanceof Error ? classifyError(err) : fallbackCode;
-  return new KordocError(message || fallbackMessage, { code, stage });
-}
-var VERSION, KordocError, SAFE_HREF_RE;
-var init_utils = __esm({
-  "src/utils.ts"() {
-    "use strict";
-    VERSION = true ? "2.5.2" : "0.0.0-dev";
-    KordocError = class extends Error {
-      code;
-      stage;
-      constructor(message, opts = {}) {
-        super(message);
-        this.name = "KordocError";
-        this.code = opts.code;
-        this.stage = opts.stage;
-      }
-    };
-    SAFE_HREF_RE = /^(?:https?:|mailto:|tel:|#)/i;
-  }
-});
-
 // src/page-range.ts
 var page_range_exports = {};
 __export(page_range_exports, {
@@ -3223,8 +3111,97 @@ async function detectZipFormat(buffer) {
 import JSZip2 from "jszip";
 import { DOMParser } from "@xmldom/xmldom";
 
+// src/utils.ts
+var VERSION = true ? "2.6.1" : "0.0.0-dev";
+function toArrayBuffer(buf) {
+  if (buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength) {
+    return buf.buffer;
+  }
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+var KordocError = class extends Error {
+  code;
+  stage;
+  constructor(message, opts = {}) {
+    super(message);
+    this.name = "KordocError";
+    this.code = opts.code;
+    this.stage = opts.stage;
+  }
+};
+function isPathTraversal(name) {
+  if (name.includes("\0")) return true;
+  const normalized = name.replace(/\\/g, "/");
+  return normalized.includes("..") || normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized);
+}
+function precheckZipSize(buffer, maxUncompressedSize = 100 * 1024 * 1024, maxEntries = 500) {
+  try {
+    const data = new DataView(buffer);
+    const len = buffer.byteLength;
+    let eocdOffset = -1;
+    for (let i = len - 22; i >= Math.max(0, len - 65557); i--) {
+      if (data.getUint32(i, true) === 101010256) {
+        eocdOffset = i;
+        break;
+      }
+    }
+    if (eocdOffset < 0) return { totalUncompressed: 0, entryCount: 0 };
+    const entryCount = data.getUint16(eocdOffset + 10, true);
+    if (entryCount > maxEntries) {
+      throw new KordocError(`ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC: ${entryCount} (\uCD5C\uB300 ${maxEntries})`);
+    }
+    const cdSize = data.getUint32(eocdOffset + 12, true);
+    const cdOffset = data.getUint32(eocdOffset + 16, true);
+    if (cdOffset + cdSize > len) return { totalUncompressed: 0, entryCount };
+    let totalUncompressed = 0;
+    let pos = cdOffset;
+    for (let i = 0; i < entryCount && pos + 46 <= cdOffset + cdSize; i++) {
+      if (data.getUint32(pos, true) !== 33639248) break;
+      totalUncompressed += data.getUint32(pos + 24, true);
+      const nameLen = data.getUint16(pos + 28, true);
+      const extraLen = data.getUint16(pos + 30, true);
+      const commentLen = data.getUint16(pos + 32, true);
+      pos += 46 + nameLen + extraLen + commentLen;
+    }
+    if (totalUncompressed > maxUncompressedSize) {
+      throw new KordocError(`ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC: ${(totalUncompressed / 1024 / 1024).toFixed(1)}MB (\uCD5C\uB300 ${maxUncompressedSize / 1024 / 1024}MB)`);
+    }
+    return { totalUncompressed, entryCount };
+  } catch (err) {
+    if (err instanceof KordocError) throw err;
+    return { totalUncompressed: 0, entryCount: 0 };
+  }
+}
+var SAFE_HREF_RE = /^(?:https?:|mailto:|tel:|#)/i;
+function sanitizeHref(href) {
+  const trimmed = href.trim();
+  if (!trimmed || !SAFE_HREF_RE.test(trimmed)) return null;
+  return trimmed;
+}
+function classifyError(err) {
+  if (!(err instanceof Error)) return "PARSE_ERROR";
+  const msg = err.message;
+  if (msg.includes("\uC554\uD638\uD654")) return "ENCRYPTED";
+  if (msg.includes("DRM")) return "DRM_PROTECTED";
+  if (msg.includes("ZIP bomb") || msg.includes("ZIP \uBE44\uC555\uCD95 \uD06C\uAE30 \uCD08\uACFC") || msg.includes("ZIP \uC5D4\uD2B8\uB9AC \uC218 \uCD08\uACFC")) return "ZIP_BOMB";
+  if (msg.includes("bomb") || msg.includes("\uD06C\uAE30 \uCD08\uACFC") || msg.includes("\uC555\uCD95 \uD574\uC81C")) return "DECOMPRESSION_BOMB";
+  if (msg.includes("\uC774\uBBF8\uC9C0 \uAE30\uBC18")) return "IMAGE_BASED_PDF";
+  if (msg.includes("\uC139\uC158") && (msg.includes("\uCC3E\uC744 \uC218 \uC5C6") || msg.includes("\uC5C6\uC74C"))) return "NO_SECTIONS";
+  if (msg.includes("\uC2DC\uADF8\uB2C8\uCC98") || msg.includes("\uBCF5\uAD6C\uD560 \uC218 \uC5C6")) return "CORRUPTED";
+  return "PARSE_ERROR";
+}
+function normalizeKordocError(err, fallbackMessage, stage = "unknown", fallbackCode = "PARSE_ERROR") {
+  if (err instanceof KordocError) {
+    if (!err.stage) err.stage = stage;
+    if (!err.code) err.code = fallbackCode;
+    return err;
+  }
+  const message = err instanceof Error ? err.message : fallbackMessage;
+  const code = err instanceof Error ? classifyError(err) : fallbackCode;
+  return new KordocError(message || fallbackMessage, { code, stage });
+}
+
 // src/table/builder.ts
-init_utils();
 var MAX_COLS = 200;
 var MAX_ROWS = 1e4;
 function buildTable(rows) {
@@ -3484,8 +3461,6 @@ var HEADING_RATIO_H2 = 1.3;
 var HEADING_RATIO_H3 = 1.15;
 
 // src/hwpx/parser.ts
-init_utils();
-init_utils();
 init_page_range();
 init_logger();
 var MAX_DECOMPRESS_SIZE = 500 * 1024 * 1024;
@@ -4327,7 +4302,6 @@ function extractTextFromNode(node) {
 }
 
 // src/hwp5/record.ts
-init_utils();
 import { inflateRawSync, inflateSync } from "zlib";
 var TAG_PARA_HEADER = 66;
 var TAG_PARA_TEXT = 67;
@@ -5378,7 +5352,6 @@ function parseLenientCfb(data) {
 }
 
 // src/hwp5/parser.ts
-init_utils();
 init_page_range();
 init_logger();
 var CFB = __toESM(require_cfb(), 1);
@@ -6034,7 +6007,6 @@ function arrangeCells(rows, cols, cells) {
 }
 
 // src/pdf/parser.ts
-init_utils();
 init_page_range();
 import { createRequire } from "module";
 import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
@@ -7926,7 +7898,6 @@ function mergeKoreanLines(text) {
 }
 
 // src/xlsx/parser.ts
-init_utils();
 import JSZip3 from "jszip";
 import { DOMParser as DOMParser2 } from "@xmldom/xmldom";
 init_logger();
@@ -8255,7 +8226,6 @@ async function parseXlsxDocument(buffer, options, existingZip) {
 }
 
 // src/docx/parser.ts
-init_utils();
 import JSZip4 from "jszip";
 import { DOMParser as DOMParser3 } from "@xmldom/xmldom";
 init_logger();
@@ -8737,7 +8707,6 @@ async function parseDocxDocument(buffer, options, existingZip) {
 }
 
 // src/index.ts
-init_utils();
 init_cli_provider();
 init_markdown_to_blocks();
 init_logger();
@@ -11241,7 +11210,6 @@ async function markdownToXlsx(markdown, options) {
 
 // src/convert/index.ts
 import { readFile } from "fs/promises";
-init_utils();
 
 // src/convert/libreoffice.ts
 import libre from "libreoffice-convert";
@@ -11255,19 +11223,250 @@ var ConvertError = class extends Error {
   }
 };
 
-// src/convert/libreoffice.ts
-var libreConvert = libre.convert;
-async function assertSofficeAvailable() {
-  const { runCommand: runCommand2 } = await Promise.resolve().then(() => (init_utils(), utils_exports));
+// src/convert/installer.ts
+import { homedir } from "os";
+import { join as join4, delimiter } from "path";
+import { mkdir, access, symlink, rm } from "fs/promises";
+import { createWriteStream } from "fs";
+import { spawn as spawn2 } from "child_process";
+var installInFlight = null;
+var CACHE_DIR = join4(homedir(), ".cache", "kordoc", "libreoffice");
+var VERSION_FILE = join4(CACHE_DIR, "version");
+var PACKAGES = {
+  darwin: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/mac/x86_64/LibreOffice_24.8.4_MacOS_x86-64.dmg",
+    binPath: "LibreOffice.app/Contents/MacOS/soffice",
+    sizeMb: 300
+  },
+  linux: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/deb/x86_64/LibreOffice_24.8.4_Linux_x86-64_deb.tar.gz",
+    binPath: "opt/libreoffice24.8/program/soffice",
+    sizeMb: 200
+  },
+  win32: {
+    url: "https://download.documentfoundation.org/libreoffice/stable/24.8.4/win/x86_64/LibreOffice_24.8.4_Win_x86-64.msi",
+    binPath: "LibreOffice/program/soffice.exe",
+    sizeMb: 350
+  }
+};
+async function findInPath() {
+  return new Promise((resolve4) => {
+    const child = spawn2("soffice", ["--version"], { stdio: "ignore" });
+    child.on("close", (code) => resolve4(code === 0 ? "soffice" : null));
+    child.on("error", () => resolve4(null));
+  });
+}
+async function findInCache() {
+  const cachedBin = join4(CACHE_DIR, "bin", "soffice");
+  try {
+    await 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(
+      join4(pf, "LibreOffice", "program", "soffice.exe"),
+      join4(pf86, "LibreOffice", "program", "soffice.exe")
+    );
+  }
+  for (const p of paths) {
+    try {
+      await access(p);
+      return p;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function downloadWithProgress(url, dest, totalBytes, onProgress) {
+  const response = await fetch(url);
+  if (!response.body) throw new Error("\uB2E4\uC6B4\uB85C\uB4DC \uC2E4\uD328: response body \uC5C6\uC74C");
+  const file = createWriteStream(dest);
+  const reader = response.body.getReader();
+  let downloaded = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      file.write(value);
+      downloaded += value.length;
+      onProgress?.(downloaded, totalBytes);
+    }
+  } finally {
+    file.end();
+    reader.releaseLock();
+  }
+}
+async function installForPlatform(pkg, onProgress) {
+  const platform = process.platform;
+  await mkdir(CACHE_DIR, { recursive: true });
+  const downloadPath = join4(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 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 child = spawn2("hdiutil", ["attach", "-nobrowse", "-mountpoint", mountPoint, downloadPath]);
+    child.on("close", (code) => code === 0 ? resolve4() : reject(new Error("dmg \uB9C8\uC6B4\uD2B8 \uC2E4\uD328")));
+  });
+  try {
+    const appSource = join4(mountPoint, "LibreOffice.app");
+    const appDest = join4(CACHE_DIR, "LibreOffice.app");
+    await new Promise((resolve4, reject) => {
+      const child = spawn2("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 = spawn2("hdiutil", ["detach", mountPoint]);
+      child.on("close", () => resolve4());
+    });
+  }
+  await rm(downloadPath, { force: true });
+  return await createSymlink(join4(CACHE_DIR, pkg.binPath));
+}
+async function installLinux(pkg, downloadPath) {
+  const extractDir = join4(CACHE_DIR, `extract-${Date.now()}`);
+  await mkdir(extractDir, { recursive: true });
+  await new Promise((resolve4, reject) => {
+    const child = spawn2("tar", ["xzf", downloadPath, "-C", extractDir]);
+    child.on("close", (code) => code === 0 ? resolve4() : reject(new Error("\uC555\uCD95 \uD574\uC81C \uC2E4\uD328")));
+  });
+  const debsDir = join4(extractDir, "DEBS");
   try {
-    await runCommand2("soffice", ["--version"]);
+    await 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 = spawn2("dpkg-deb", ["-x", join4(debsDir, entry), CACHE_DIR]);
+          child.on("close", (code) => code === 0 ? resolve4() : reject(new Error(`${entry} \uCD94\uCD9C \uC2E4\uD328`)));
+        });
+      }
+    }
   } catch {
+  }
+  await rm(downloadPath, { force: true });
+  await rm(extractDir, { recursive: true, force: true });
+  return await createSymlink(join4(CACHE_DIR, pkg.binPath));
+}
+async function installWindows(pkg, downloadPath) {
+  await new Promise((resolve4, reject) => {
+    const child = spawn2("msiexec", ["/a", downloadPath, "/qn", `TARGETDIR=${CACHE_DIR}`]);
+    child.on("close", (code) => code === 0 ? resolve4() : reject(new Error("MSI \uC124\uCE58 \uC2E4\uD328")));
+  });
+  await rm(downloadPath, { force: true });
+  return join4(CACHE_DIR, pkg.binPath);
+}
+async function createSymlink(actualBin) {
+  const binDir = join4(CACHE_DIR, "bin");
+  await mkdir(binDir, { recursive: true });
+  const linkBin = join4(binDir, "soffice");
+  try {
+    await symlink(actualBin, linkBin);
+  } catch {
+  }
+  process.env.PATH = `${binDir}${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",
-      "soffice\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. LibreOffice\uB97C \uC124\uCE58\uD574 \uC8FC\uC138\uC694."
+      "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 = libre.convert;
 async function convertBuffer(buffer, targetExt, timeoutMs = 6e4) {
   return new Promise((resolve4, reject) => {
     const timer = setTimeout(() => {
@@ -11291,6 +11490,54 @@ async function convertBuffer(buffer, targetExt, timeoutMs = 6e4) {
   });
 }
 
+// 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 = [];
@@ -11315,81 +11562,129 @@ async function acquireConvertLock() {
   });
 }
 async function convertToPdf(input, options) {
-  let buffer;
-  try {
-    if (typeof input === "string") {
-      buffer = await readFile(input);
-    } else if (Buffer.isBuffer(input)) {
-      buffer = input;
-    } else {
-      buffer = Buffer.from(input);
-    }
-  } catch (err) {
-    return {
-      success: false,
-      code: "PARSE_ERROR",
-      error: `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`,
-      stage: "detect"
-    };
+  const emitter = new ConvertEventEmitter();
+  if (options?.onEvent) {
+    emitter.setListener(options.onEvent);
   }
-  const MAX_FILE_SIZE = 500 * 1024 * 1024;
-  if (buffer.length > MAX_FILE_SIZE) {
-    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));
-  if (format !== "hwp" && format !== "hwpx") {
-    return {
-      success: false,
-      code: "UNSUPPORTED_FORMAT",
-      error: `\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uD3EC\uB9F7\uC785\uB2C8\uB2E4: ${format}`,
-      stage: "detect"
-    };
+  if (options?.onProgress) {
+    const legacyProgress = options.onProgress;
+    emitter.setListener((event) => {
+      if (event.type === "convert" && event.stage === "convert_progress") {
+        legacyProgress(event.percent, event.message);
+      }
+    });
   }
   try {
-    await assertSofficeAvailable();
-  } catch (err) {
-    if (err instanceof ConvertError) {
+    emitter.detect("reading", "\uC785\uB825 \uD30C\uC77C \uC77D\uB294 \uC911...");
+    let buffer;
+    try {
+      if (typeof input === "string") {
+        buffer = await 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: err.code,
-        error: err.message,
-        stage: "validate"
+        code: "PARSE_ERROR",
+        error: `\uC785\uB825 \uC77D\uAE30 \uC2E4\uD328: ${err instanceof Error ? err.message : String(err)}`,
+        stage: "detect"
       };
     }
-    throw err;
-  }
-  const releaseLock = await acquireConvertLock();
-  try {
-    options?.onProgress?.(10, "convert");
-    const pdf = await convertBuffer(buffer, ".pdf", options?.timeoutMs);
-    options?.onProgress?.(100, "done");
-    return {
-      success: true,
-      pdf: new Uint8Array(pdf),
-      sourceFormat: format
-    };
-  } catch (err) {
-    if (err instanceof ConvertError) {
+    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: err.code,
-        error: err.message,
+        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 pdf = await convertBuffer(buffer, ".pdf", options?.timeoutMs);
+      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: classifyError(err),
-      error: err instanceof Error ? err.message : "\uBCC0\uD658 \uC2E4\uD328",
+      code: "PARSE_ERROR",
+      error: errorMsg,
       stage: "convert"
     };
-  } finally {
-    releaseLock();
   }
 }
 async function convertHwpToPdf(input, options) {
@@ -11417,9 +11712,6 @@ async function convertHwpxToPdf(input, options) {
   return result;
 }
 
-// src/index.ts
-init_utils();
-
 // src/ocr/api-key-rotation.ts
 var AllKeysCoolingDownError = class extends Error {
   waitMs;
@@ -11514,9 +11806,9 @@ var ApiKeyRotationPool = class _ApiKeyRotationPool {
 };
 
 // src/pipeline/unified-ocr.ts
-import { mkdir, readdir, readFile as readFile2, stat, writeFile } from "fs/promises";
-import { basename as basename2, dirname as dirname3, extname, join as join4, resolve as resolve3 } from "path";
-import { spawn as spawn2 } from "child_process";
+import { mkdir as mkdir2, readdir, readFile as readFile2, stat, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename2, delimiter as delimiter2, dirname as dirname3, extname, join as join5, resolve as resolve3 } from "path";
+import { spawn as spawn3 } from "child_process";
 import { performance } from "perf_hooks";
 init_logger();
 
@@ -11652,13 +11944,13 @@ function elapsedMs(startAt) {
 async function runUnifiedOcrPipeline(inputPath, options = {}) {
   const absInput = resolve3(inputPath);
   const stem = basename2(absInput, extname(absInput));
-  const workspaceDir = resolve3(options.workspaceDir ?? join4(dirname3(absInput), `${stem}_ocr_workspace`));
-  const imagesDir = join4(workspaceDir, "images");
-  const rawDir = join4(workspaceDir, "ocr", "raw");
-  const diffDir = join4(workspaceDir, "ocr", "diff");
-  const outputPath = resolve3(options.outputPath ?? join4(dirname3(absInput), `${stem}.md`));
-  const reportPath = join4(workspaceDir, "run-report.json");
-  const modelCachePath = join4(dirname3(absInput), ".kordoc-model-cache.json");
+  const workspaceDir = resolve3(options.workspaceDir ?? join5(dirname3(absInput), `${stem}_ocr_workspace`));
+  const imagesDir = join5(workspaceDir, "images");
+  const rawDir = join5(workspaceDir, "ocr", "raw");
+  const diffDir = join5(workspaceDir, "ocr", "diff");
+  const outputPath = resolve3(options.outputPath ?? join5(dirname3(absInput), `${stem}.md`));
+  const reportPath = join5(workspaceDir, "run-report.json");
+  const modelCachePath = join5(dirname3(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;
@@ -11672,9 +11964,9 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
   const keyPool = ApiKeyRotationPool.fromEnv();
   const runId = options.runId ?? generateRunId("ocr");
   const logger = (options.logger ?? createLoggerFromEnv()).withRun(runId).child({ component: "pipeline/unified-ocr.ts" });
-  await mkdir(imagesDir, { recursive: true });
-  await mkdir(rawDir, { recursive: true });
-  await mkdir(diffDir, { recursive: true });
+  await mkdir2(imagesDir, { recursive: true });
+  await mkdir2(rawDir, { recursive: true });
+  await mkdir2(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 });
@@ -11691,11 +11983,29 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     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 (extname(absInput).toLowerCase() !== ".pdf") {
-      await assertSofficeAvailable();
-      workingPdfPath = join4(workspaceDir, `${stem}.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 {
+            }
+          }
+        });
+      }
+      if (options.sofficePath) {
+        const sofficeDir = dirname3(options.sofficePath);
+        process.env.PATH = `${sofficeDir}${delimiter2}${process.env.PATH ?? ""}`;
+        convertEmitter.validate("soffice_found", "\uC9C1\uC811 \uC9C0\uC815\uB41C LibreOffice \uACBD\uB85C \uC0AC\uC6A9", { sofficePath: options.sofficePath });
+      } else {
+        await resolveSoffice(convertEmitter, options.autoInstallLibreOffice ?? false);
+      }
+      workingPdfPath = join5(workspaceDir, `${stem}.pdf`);
       const inputBuffer = await readFile2(absInput);
       const out = await convertBuffer(inputBuffer, ".pdf");
-      await writeFile(workingPdfPath, out);
+      await writeFile2(workingPdfPath, out);
     }
     timingsMs.convert = elapsedMs(convertStart);
     markStageDone("convert", "PDF \uBCC0\uD658 \uC644\uB8CC");
@@ -11706,10 +12016,10 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
     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, join4(imagesDir, "page")]);
+    await runCommand("pdftoppm", ["-png", "-r", String(dpi), "-f", "1", "-l", "1", workingPdfPath, join5(imagesDir, "page")]);
     const firstFiles = (await 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 = join4(imagesDir, firstFiles[0]);
+    const probeImage = join5(imagesDir, firstFiles[0]);
     markStageProgress("render", Math.round(1 / totalPages * 100), 1, totalPages, `\uD398\uC774\uC9C0 1/${totalPages} \uB80C\uB354\uB9C1`);
     const probeStart = performance.now();
     currentStage = "probe";
@@ -11755,7 +12065,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       try {
         await queue2.enqueue({ pageNumber: 1, imagePath: probeImage });
         if (totalPages > 1) {
-          for await (const item of renderPdfToPngStream(workingPdfPath, join4(imagesDir, "page"), dpi, totalPages, 2)) {
+          for await (const item of renderPdfToPngStream(workingPdfPath, join5(imagesDir, "page"), dpi, totalPages, 2)) {
             await queue2.enqueue(item);
             renderDone++;
             markStageProgress("render", Math.round(renderDone / totalPages * 100), renderDone, totalPages, `\uD398\uC774\uC9C0 ${renderDone}/${totalPages} \uB80C\uB354\uB9C1`);
@@ -11805,8 +12115,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 = join4(rawDir, `page_${String(pageNum).padStart(4, "0")}.md`);
-      await writeFile(pagePath, markdown, "utf-8");
+      const pagePath = join5(rawDir, `page_${String(pageNum).padStart(4, "0")}.md`);
+      await writeFile2(pagePath, markdown, "utf-8");
       rawPagePaths.push(pagePath);
     }
     const mergeStart = performance.now();
@@ -11814,7 +12124,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 writeFile(outputPath, merged, "utf-8");
+    await writeFile2(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 });
@@ -11830,7 +12140,7 @@ async function runUnifiedOcrPipeline(inputPath, options = {}) {
       timingsMs,
       modelCachePath
     };
-    await writeFile(reportPath, JSON.stringify(report, null, 2), "utf-8");
+    await writeFile2(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) {
@@ -11921,7 +12231,7 @@ async function* renderPdfToPngStream(pdfPath, prefixPath, dpi, totalPages, start
       ]);
       const files = await readdir(imagesDir);
       const pageFiles = files.filter((f) => f.endsWith(".png")).sort((a, b) => naturalPageSort(a, b));
-      const imagePath = join4(imagesDir, pageFiles[pageFiles.length - 1]);
+      const imagePath = join5(imagesDir, pageFiles[pageFiles.length - 1]);
       yield { pageNumber: page, imagePath };
     } catch (err) {
       yield {
@@ -11934,7 +12244,7 @@ async function* renderPdfToPngStream(pdfPath, prefixPath, dpi, totalPages, start
 }
 async function runCommand(cmd, args) {
   await new Promise((resolvePromise, reject) => {
-    const child = spawn2(cmd, args, { stdio: "pipe" });
+    const child = spawn3(cmd, args, { stdio: "pipe" });
     let stderr = "";
     child.stderr.on("data", (d) => {
       stderr += String(d);
@@ -11948,7 +12258,7 @@ async function runCommand(cmd, args) {
 }
 async function runCommandWithStdout(cmd, args) {
   return await new Promise((resolvePromise, reject) => {
-    const child = spawn2(cmd, args, { stdio: "pipe" });
+    const child = spawn3(cmd, args, { stdio: "pipe" });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (d) => {
@@ -12068,7 +12378,7 @@ async function updateModelCache(path, probes) {
     }
   }
   current.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await writeFile(path, JSON.stringify(current, null, 2), "utf-8");
+  await writeFile2(path, JSON.stringify(current, null, 2), "utf-8");
 }
 async function ocrWorkerPool(input) {
   const { queue: queue2, workerCount, ocrInput, onPageDone } = input;
@@ -12264,6 +12574,16 @@ 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",