@heripo/pdf-parser 0.1.30 → 0.1.31

package/dist/index.cjs

@@ -40,7 +40,7 @@ module.exports = __toCommonJS(src_exports);
 
 // src/core/pdf-parser.ts
 var import_docling_sdk = require("docling-sdk");
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 
 // src/config/constants.ts
 var PDF_PARSER = {
@@ -84,7 +84,7 @@ var DOCLING_ENVIRONMENT = {
 var PAGE_RENDERING = {
   /** Default rendering DPI for VLM text recognition quality */
   DEFAULT_DPI: 200,
-  /** Low-resolution DPI for OCR strategy sampling */
+  /** Low-resolution DPI for language detection sampling */
   SAMPLE_DPI: 150
 };
 var CHUNKED_CONVERSION = {
@@ -1015,17 +1015,14 @@ function checkMacOSVersion() {
   }
 }
 
-// src/errors/image-pdf-fallback-error.ts
-var ImagePdfFallbackError = class extends Error {
-  constructor(originalError, fallbackError) {
-    super(
-      `PDF conversion failed with fallback. Original: ${originalError.message}. Fallback: ${fallbackError.message}`
-    );
-    this.originalError = originalError;
-    this.fallbackError = fallbackError;
-  }
-  name = "ImagePdfFallbackError";
-};
+// src/core/pdf-converter.ts
+var import_node_fs17 = require("fs");
+var import_node_path17 = require("path");
+
+// src/detectors/pdf-language-detector.ts
+var import_model = require("@heripo/model");
+var import_node_fs = require("fs");
+var import_v4 = require("zod/v4");
 
 // src/processors/pdf-text-extractor.ts
 var PdfTextExtractor = class _PdfTextExtractor {
@@ -1156,6 +1153,374 @@ var PdfTextExtractor = class _PdfTextExtractor {
   }
 };
 
+// src/prompts/korean-document-detection-prompt.ts
+var KOREAN_DOCUMENT_DETECTION_PROMPT = `Look at this page image carefully and identify all languages present on this page.
+
+Return an array of ocrmac-compatible language tags ordered by prevalence (primary language first).
+Use ko-KR when Korean text is present, even when the page also contains Hanja (\u6F22\u5B57/Chinese characters), English, numbers, tables, or captions.
+
+Supported tags: ar-SA, ars-SA, cs-CZ, da-DK, de-DE, en-US, es-ES, fr-FR, id-ID, it-IT, ja-JP, ko-KR, ms-MY, nb-NO, nl-NL, nn-NO, no-NO, pl-PL, pt-BR, ro-RO, ru-RU, sv-SE, th-TH, tr-TR, uk-UA, vi-VT, yue-Hans, yue-Hant, zh-Hans, zh-Hant.
+Examples: ["ko-KR", "en-US"], ["ja-JP"], ["zh-Hant", "en-US"]`;
+
+// src/detectors/pdf-language-detector.ts
+var DEFAULT_MAX_SAMPLE_PAGES = 15;
+var DEFAULT_MAX_RETRIES = 3;
+var EDGE_TRIM_RATIO = 0.1;
+var HANGUL_REGEX = /[\u1100-\u11ff\u3130-\u318f\uac00-\ud7af]/g;
+var JAPANESE_KANA_REGEX = /[\u3040-\u30ff]/g;
+var LATIN_REGEX = /[A-Za-z]/g;
+var DEFAULT_OCR_LANGUAGES = ["ko-KR", "en-US"];
+var languageDetectionSchema = import_v4.z.object({
+  detectedLanguages: import_v4.z.array(import_v4.z.string()).describe(
+    "BCP 47 language tags found on this page, ordered by prevalence."
+  )
+});
+var PdfLanguageDetector = class {
+  constructor(logger, pageRenderer, textExtractor) {
+    this.logger = logger;
+    this.pageRenderer = pageRenderer;
+    this.textExtractor = textExtractor ?? new PdfTextExtractor(logger);
+  }
+  textExtractor;
+  async detect(pdfPath, outputDir, options) {
+    this.logger.info(
+      "[PdfLanguageDetector] Starting PDF language detection..."
+    );
+    const textLayerResult = await this.detectFromTextLayer(pdfPath);
+    if (textLayerResult) {
+      return textLayerResult;
+    }
+    if (!options?.model) {
+      this.logger.info(
+        `[PdfLanguageDetector] Language detection model not configured; using default OCR languages: ${JSON.stringify(DEFAULT_OCR_LANGUAGES)}`
+      );
+      return {
+        detectedLanguages: [...DEFAULT_OCR_LANGUAGES],
+        reason: "Language detection model not configured",
+        sampledPages: 0,
+        totalPages: 0,
+        source: "default"
+      };
+    }
+    return this.detectFromSampledPages(pdfPath, outputDir, {
+      ...options,
+      model: options.model
+    });
+  }
+  async detectFromTextLayer(pdfPath) {
+    try {
+      const totalPages = await this.textExtractor.getPageCount(pdfPath);
+      if (totalPages === 0) return null;
+      const fullText = await this.textExtractor.extractFullText(pdfPath);
+      if (fullText.trim().length === 0) {
+        this.logger.debug(
+          "[PdfLanguageDetector] No text in text layer; falling back to sampled language detection"
+        );
+        return null;
+      }
+      const detectedLanguages = this.detectLanguagesFromText(fullText);
+      if (detectedLanguages.length === 0) {
+        this.logger.debug(
+          "[PdfLanguageDetector] No known language signal in text layer; falling back to sampled language detection"
+        );
+        return null;
+      }
+      this.logger.info(
+        `[PdfLanguageDetector] Languages detected in text layer: ${detectedLanguages.join(", ")}`
+      );
+      return {
+        detectedLanguages,
+        reason: `Languages found in PDF text layer (${totalPages} pages checked)`,
+        sampledPages: totalPages,
+        totalPages,
+        source: "text-layer"
+      };
+    } catch {
+      this.logger.debug(
+        "[PdfLanguageDetector] Text layer language detection failed; falling back to sampled language detection"
+      );
+      return null;
+    }
+  }
+  detectLanguagesFromText(text) {
+    const scores = [
+      { tag: "ko-KR", count: this.countMatches(text, HANGUL_REGEX) },
+      { tag: "ja-JP", count: this.countMatches(text, JAPANESE_KANA_REGEX) },
+      { tag: "en-US", count: this.countMatches(text, LATIN_REGEX) }
+    ];
+    return scores.filter(({ count }) => count > 0).sort((a, b) => b.count - a.count).map(({ tag }) => tag);
+  }
+  countMatches(text, regex) {
+    regex.lastIndex = 0;
+    return text.match(regex)?.length ?? 0;
+  }
+  async detectFromSampledPages(pdfPath, outputDir, options) {
+    const renderResult = await this.pageRenderer.renderPages(
+      pdfPath,
+      outputDir,
+      {
+        dpi: PAGE_RENDERING.SAMPLE_DPI
+      }
+    );
+    if (renderResult.pageCount === 0) {
+      this.logger.info(
+        `[PdfLanguageDetector] No pages found; using default OCR languages: ${JSON.stringify(DEFAULT_OCR_LANGUAGES)}`
+      );
+      return {
+        detectedLanguages: [...DEFAULT_OCR_LANGUAGES],
+        reason: "No pages found in PDF",
+        sampledPages: 0,
+        totalPages: 0,
+        source: "default"
+      };
+    }
+    const sampleIndices = this.selectSamplePages(
+      renderResult.pageCount,
+      options.maxSamplePages ?? DEFAULT_MAX_SAMPLE_PAGES
+    );
+    this.logger.info(
+      `[PdfLanguageDetector] Sampling ${sampleIndices.length} of ${renderResult.pageCount} pages for language detection: [${sampleIndices.map((i) => i + 1).join(", ")}]`
+    );
+    const languageFrequency = /* @__PURE__ */ new Map();
+    let sampledPages = 0;
+    for (const index of sampleIndices) {
+      const pageFile = renderResult.pageFiles[index];
+      if (!pageFile) continue;
+      sampledPages += 1;
+      const detectedLanguages2 = await this.analyzeSamplePage(
+        pageFile,
+        index + 1,
+        options
+      );
+      for (const language of detectedLanguages2) {
+        languageFrequency.set(
+          language,
+          (languageFrequency.get(language) ?? 0) + 1
+        );
+      }
+    }
+    const detectedLanguages = this.aggregateLanguages(languageFrequency);
+    if (detectedLanguages.length === 0) {
+      this.logger.info(
+        `[PdfLanguageDetector] No languages detected from sampled pages; using default OCR languages: ${JSON.stringify(DEFAULT_OCR_LANGUAGES)}`
+      );
+      return {
+        detectedLanguages: [...DEFAULT_OCR_LANGUAGES],
+        reason: `No language detected in ${sampledPages} sampled pages`,
+        sampledPages,
+        totalPages: renderResult.pageCount,
+        source: "default"
+      };
+    }
+    this.logger.info(
+      `[PdfLanguageDetector] Languages detected from sampled pages: ${detectedLanguages.join(", ")}`
+    );
+    return {
+      detectedLanguages,
+      reason: `Languages detected in ${sampledPages} sampled pages`,
+      sampledPages,
+      totalPages: renderResult.pageCount,
+      source: "vlm"
+    };
+  }
+  selectSamplePages(totalPages, maxSamples) {
+    if (totalPages === 0) return [];
+    if (totalPages <= maxSamples) {
+      return Array.from({ length: totalPages }, (_, i) => i);
+    }
+    const trimCount = Math.max(1, Math.ceil(totalPages * EDGE_TRIM_RATIO));
+    const start = trimCount;
+    const end = totalPages - trimCount;
+    const eligibleCount = end - start;
+    if (eligibleCount <= 0) {
+      return [Math.floor(totalPages / 2)];
+    }
+    if (eligibleCount <= maxSamples) {
+      return Array.from({ length: eligibleCount }, (_, i) => start + i);
+    }
+    const step = eligibleCount / maxSamples;
+    return Array.from(
+      { length: maxSamples },
+      (_, i) => start + Math.floor(i * step)
+    );
+  }
+  async analyzeSamplePage(pageFile, pageNo, options) {
+    this.logger.debug(
+      `[PdfLanguageDetector] Analyzing page ${pageNo} for language...`
+    );
+    const imageData = new Uint8Array((0, import_node_fs.readFileSync)(pageFile));
+    const result = await LLMCaller.callVision({
+      schema: languageDetectionSchema,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: KOREAN_DOCUMENT_DETECTION_PROMPT
+            },
+            {
+              type: "image",
+              image: imageData,
+              mediaType: "image/png"
+            }
+          ]
+        }
+      ],
+      primaryModel: options.model,
+      maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+      temperature: options.temperature ?? 0,
+      abortSignal: options.abortSignal,
+      component: "PdfLanguageDetector",
+      phase: "language-detection"
+    });
+    options.aggregator?.track(result.usage);
+    const output = result.output;
+    const detectedLanguages = output.detectedLanguages.map(import_model.normalizeToBcp47).filter((tag) => tag !== null);
+    this.logger.debug(
+      `[PdfLanguageDetector] Page ${pageNo}: detectedLanguages=${detectedLanguages.join(",")}`
+    );
+    return detectedLanguages;
+  }
+  aggregateLanguages(languageFrequency) {
+    return [...languageFrequency.entries()].sort((a, b) => b[1] - a[1]).map(([language]) => language);
+  }
+};
+
+// src/errors/image-pdf-fallback-error.ts
+var ImagePdfFallbackError = class extends Error {
+  constructor(originalError, fallbackError) {
+    super(
+      `PDF conversion failed with fallback. Original: ${originalError.message}. Fallback: ${fallbackError.message}`
+    );
+    this.originalError = originalError;
+    this.fallbackError = fallbackError;
+  }
+  name = "ImagePdfFallbackError";
+};
+
+// src/processors/page-renderer.ts
+var import_node_fs2 = require("fs");
+var import_node_path3 = require("path");
+var PROGRESS_LOG_PERCENT_STEP = 10;
+var PageRenderer = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  lastLoggedPercent = 0;
+  /**
+   * Render all pages of a PDF to individual PNG files.
+   *
+   * Uses per-page rendering (`magick 'input.pdf[N]'`) when page count is known,
+   * limiting peak memory to ~15MB/page instead of loading all pages at once.
+   *
+   * @param pdfPath - Absolute path to the source PDF file
+   * @param outputDir - Directory where pages/ subdirectory will be created
+   * @param options - Rendering options
+   * @returns Render result with page count and file paths
+   */
+  async renderPages(pdfPath, outputDir, options) {
+    const dpi = options?.dpi ?? PAGE_RENDERING.DEFAULT_DPI;
+    const pagesDir = (0, import_node_path3.join)(outputDir, "pages");
+    if (!(0, import_node_fs2.existsSync)(pagesDir)) {
+      (0, import_node_fs2.mkdirSync)(pagesDir, { recursive: true });
+    }
+    const totalPages = await this.getPageCount(pdfPath);
+    if (totalPages > 0) {
+      this.logger.info(
+        `[PageRenderer] Rendering ${totalPages} pages at ${dpi} DPI...`
+      );
+      this.lastLoggedPercent = 0;
+      for (let i = 0; i < totalPages; i++) {
+        const result = await spawnAsync(
+          "magick",
+          [
+            "-density",
+            dpi.toString(),
+            `${pdfPath}[${i}]`,
+            "-background",
+            "white",
+            "-alpha",
+            "remove",
+            "-alpha",
+            "off",
+            (0, import_node_path3.join)(pagesDir, `page_${i}.png`)
+          ],
+          { captureStdout: false }
+        );
+        if (result.code !== 0) {
+          throw new Error(
+            `[PageRenderer] Failed to render page ${i + 1}/${totalPages}: ${result.stderr || "Unknown error"}`
+          );
+        }
+        this.logProgress(i + 1, totalPages);
+      }
+    } else {
+      this.logger.info(`[PageRenderer] Rendering PDF at ${dpi} DPI...`);
+      const result = await spawnAsync(
+        "magick",
+        [
+          "-density",
+          dpi.toString(),
+          pdfPath,
+          "-background",
+          "white",
+          "-alpha",
+          "remove",
+          "-alpha",
+          "off",
+          (0, import_node_path3.join)(pagesDir, "page_%d.png")
+        ],
+        { captureStdout: false }
+      );
+      if (result.code !== 0) {
+        throw new Error(
+          `[PageRenderer] Failed to render PDF pages: ${result.stderr || "Unknown error"}`
+        );
+      }
+    }
+    const pageFiles = (0, import_node_fs2.readdirSync)(pagesDir).filter((f) => f.startsWith("page_") && f.endsWith(".png")).sort((a, b) => {
+      const numA = parseInt(a.replace("page_", "").replace(".png", ""), 10);
+      const numB = parseInt(b.replace("page_", "").replace(".png", ""), 10);
+      return numA - numB;
+    }).map((f) => (0, import_node_path3.join)(pagesDir, f));
+    this.logger.info(
+      `[PageRenderer] Rendered ${pageFiles.length} pages to ${pagesDir}`
+    );
+    return {
+      pageCount: pageFiles.length,
+      pagesDir,
+      pageFiles
+    };
+  }
+  /**
+   * Log rendering progress at appropriate intervals (every 10%).
+   */
+  logProgress(current, total) {
+    const percent = Math.floor(current / total * 100);
+    if (percent >= this.lastLoggedPercent + PROGRESS_LOG_PERCENT_STEP || current === total) {
+      this.lastLoggedPercent = percent;
+      this.logger.info(
+        `[PageRenderer] Rendering pages: ${current}/${total} (${percent}%)`
+      );
+    }
+  }
+  /**
+   * Get total page count using pdfinfo.
+   * Returns 0 on failure (progress logging will be skipped).
+   */
+  async getPageCount(pdfPath) {
+    try {
+      const result = await spawnAsync("pdfinfo", [pdfPath]);
+      if (result.code !== 0) return 0;
+      const match = result.stdout.match(/^Pages:\s+(\d+)/m);
+      return match ? parseInt(match[1], 10) : 0;
+    } catch {
+      return 0;
+    }
+  }
+};
+
 // src/validators/document-type-validator.ts
 var import_zod = require("zod");
 
@@ -1247,7 +1612,7 @@ ${combinedText}`,
 };
 
 // src/core/chunked-pdf-converter.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path7 = require("path");
 
 // src/processors/docling-document-merger.ts
@@ -1380,15 +1745,15 @@ var DoclingDocumentMerger = class {
 };
 
 // src/processors/image-extractor.ts
-var import_node_fs2 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path4 = require("path");
 var import_node_stream = require("stream");
 var import_promises3 = require("stream/promises");
 var yauzl = __toESM(require("yauzl"), 1);
 
 // src/utils/jq.ts
 var import_node_child_process3 = require("child_process");
-var import_node_fs = require("fs");
+var import_node_fs3 = require("fs");
 var import_promises = require("fs/promises");
 var import_promises2 = require("stream/promises");
 function getJqPath() {
@@ -1459,7 +1824,7 @@ function runJqFileToFile(program, inputPath, outputPath) {
     child.stderr.on("data", (chunk) => {
       state.stderr += chunk;
     });
-    const ws = (0, import_node_fs.createWriteStream)(outputPath);
+    const ws = (0, import_node_fs3.createWriteStream)(outputPath);
     function trySettle() {
       if (state.settled) return;
       if (!state.pipelineDone || state.exitCode === null) return;
@@ -1593,9 +1958,9 @@ var ImageExtractor = class _ImageExtractor {
         }
         zipfile.readEntry();
         zipfile.on("entry", (entry) => {
-          const entryPath = (0, import_node_path3.join)(targetDir, entry.fileName);
+          const entryPath = (0, import_node_path4.join)(targetDir, entry.fileName);
           if (/\/$/.test(entry.fileName)) {
-            (0, import_node_fs2.mkdirSync)(entryPath, { recursive: true });
+            (0, import_node_fs4.mkdirSync)(entryPath, { recursive: true });
             zipfile.readEntry();
           } else {
             zipfile.openReadStream(entry, (err2, readStream) => {
@@ -1603,8 +1968,8 @@ var ImageExtractor = class _ImageExtractor {
                 reject(err2 || new Error("Failed to open read stream"));
                 return;
               }
-              (0, import_node_fs2.mkdirSync)((0, import_node_path3.join)(entryPath, ".."), { recursive: true });
-              const writeStream = (0, import_node_fs2.createWriteStream)(entryPath);
+              (0, import_node_fs4.mkdirSync)((0, import_node_path4.join)(entryPath, ".."), { recursive: true });
+              const writeStream = (0, import_node_fs4.createWriteStream)(entryPath);
               readStream.pipe(writeStream);
               writeStream.on("finish", () => {
                 zipfile.readEntry();
@@ -1627,9 +1992,9 @@ var ImageExtractor = class _ImageExtractor {
     const PREFIX = "data:image/png;base64,";
     const base64Content = base64Data.startsWith(PREFIX) ? base64Data.slice(PREFIX.length) : base64Data;
     const filename = `${prefix}_${index}.png`;
-    const filepath = (0, import_node_path3.join)(imagesDir, filename);
+    const filepath = (0, import_node_path4.join)(imagesDir, filename);
     const buffer = Buffer.from(base64Content, "base64");
-    (0, import_node_fs2.writeFileSync)(filepath, buffer);
+    (0, import_node_fs4.writeFileSync)(filepath, buffer);
     return `${dirName}/${filename}`;
   }
   /**
@@ -1661,9 +2026,9 @@ var ImageExtractor = class _ImageExtractor {
         }
         const base64Content = pending.slice(dataStart, quoteIdx);
         const filename = `image_${imageIndex}.png`;
-        const filepath = (0, import_node_path3.join)(imagesDir, filename);
+        const filepath = (0, import_node_path4.join)(imagesDir, filename);
         const buf = Buffer.from(base64Content, "base64");
-        (0, import_node_fs2.writeFileSync)(filepath, buf);
+        (0, import_node_fs4.writeFileSync)(filepath, buf);
         const relativePath = `images/${filename}`;
         imageIndex++;
         pending = pending.slice(quoteIdx + 1);
@@ -1688,8 +2053,8 @@ var ImageExtractor = class _ImageExtractor {
         callback();
       }
     });
-    const rs = (0, import_node_fs2.createReadStream)(htmlInputPath, { encoding: "utf-8" });
-    const ws = (0, import_node_fs2.createWriteStream)(htmlOutputPath, { encoding: "utf-8" });
+    const rs = (0, import_node_fs4.createReadStream)(htmlInputPath, { encoding: "utf-8" });
+    const ws = (0, import_node_fs4.createWriteStream)(htmlOutputPath, { encoding: "utf-8" });
     await (0, import_promises3.pipeline)(rs, transform, ws);
     return imageIndex;
   }
@@ -1705,19 +2070,19 @@ var ImageExtractor = class _ImageExtractor {
    */
   static async saveDocumentsWithExtractedImages(logger, outputDir, filename, jsonSourcePath, htmlSourcePath) {
     try {
-      if ((0, import_node_fs2.existsSync)(outputDir)) {
-        (0, import_node_fs2.rmSync)(outputDir, { recursive: true, force: true });
+      if ((0, import_node_fs4.existsSync)(outputDir)) {
+        (0, import_node_fs4.rmSync)(outputDir, { recursive: true, force: true });
       }
     } catch (e) {
       logger.warn("[PDFConverter] Failed to clear output directory:", e);
     }
-    (0, import_node_fs2.mkdirSync)(outputDir, { recursive: true });
-    const baseName = filename.replace((0, import_node_path3.extname)(filename), "");
-    const jsonPath = (0, import_node_path3.join)(outputDir, `${baseName}.json`);
+    (0, import_node_fs4.mkdirSync)(outputDir, { recursive: true });
+    const baseName = filename.replace((0, import_node_path4.extname)(filename), "");
+    const jsonPath = (0, import_node_path4.join)(outputDir, `${baseName}.json`);
     try {
-      const imagesDir = (0, import_node_path3.join)(outputDir, "images");
-      if (!(0, import_node_fs2.existsSync)(imagesDir)) {
-        (0, import_node_fs2.mkdirSync)(imagesDir, { recursive: true });
+      const imagesDir = (0, import_node_path4.join)(outputDir, "images");
+      if (!(0, import_node_fs4.existsSync)(imagesDir)) {
+        (0, import_node_fs4.mkdirSync)(imagesDir, { recursive: true });
       }
       const imageCount = await jqExtractBase64PngStringsStreaming(
         jsonSourcePath,
@@ -1751,11 +2116,11 @@ var ImageExtractor = class _ImageExtractor {
       throw e;
     }
     logger.info("[PDFConverter] Saved JSON:", jsonPath);
-    const htmlPath = (0, import_node_path3.join)(outputDir, `${baseName}.html`);
+    const htmlPath = (0, import_node_path4.join)(outputDir, `${baseName}.html`);
     try {
-      const imagesDir = (0, import_node_path3.join)(outputDir, "images");
-      if (!(0, import_node_fs2.existsSync)(imagesDir)) {
-        (0, import_node_fs2.mkdirSync)(imagesDir, { recursive: true });
+      const imagesDir = (0, import_node_path4.join)(outputDir, "images");
+      if (!(0, import_node_fs4.existsSync)(imagesDir)) {
+        (0, import_node_fs4.mkdirSync)(imagesDir, { recursive: true });
       }
       const htmlImageCount = await _ImageExtractor.extractImagesFromHtmlStream(
         htmlSourcePath,
@@ -1770,8 +2135,8 @@ var ImageExtractor = class _ImageExtractor {
         "[PDFConverter] Failed to extract images from HTML, copying original. Error:",
         e
       );
-      const rs = (0, import_node_fs2.createReadStream)(htmlSourcePath);
-      const ws = (0, import_node_fs2.createWriteStream)(htmlPath);
+      const rs = (0, import_node_fs4.createReadStream)(htmlSourcePath);
+      const ws = (0, import_node_fs4.createWriteStream)(htmlPath);
       await (0, import_promises3.pipeline)(rs, ws);
     }
     logger.info("[PDFConverter] Saved HTML:", htmlPath);
@@ -1792,16 +2157,16 @@ var ImageExtractor = class _ImageExtractor {
   static async extractAndSaveDocumentsFromZip(logger, zipPath, extractDir, outputDir) {
     logger.info("[PDFConverter] Extracting ZIP file...");
     await _ImageExtractor.extractZip(zipPath, extractDir);
-    const files = (0, import_node_fs2.readdirSync)(extractDir);
-    const jsonFile = files.find((f) => (0, import_node_path3.extname)(f).toLowerCase() === ".json");
-    const htmlFile = files.find((f) => (0, import_node_path3.extname)(f).toLowerCase() === ".html");
+    const files = (0, import_node_fs4.readdirSync)(extractDir);
+    const jsonFile = files.find((f) => (0, import_node_path4.extname)(f).toLowerCase() === ".json");
+    const htmlFile = files.find((f) => (0, import_node_path4.extname)(f).toLowerCase() === ".html");
     if (!jsonFile || !htmlFile) {
       throw new Error(
         `Expected one JSON and one HTML file in extracted directory. Found: ${files.join(", ")}`
       );
     }
-    const jsonPath = (0, import_node_path3.join)(extractDir, jsonFile);
-    const htmlPath = (0, import_node_path3.join)(extractDir, htmlFile);
+    const jsonPath = (0, import_node_path4.join)(extractDir, jsonFile);
+    const htmlPath = (0, import_node_path4.join)(extractDir, htmlFile);
     logger.info("[PDFConverter] Saving converted files to output...");
     await _ImageExtractor.saveDocumentsWithExtractedImages(
       logger,
@@ -1815,7 +2180,7 @@ var ImageExtractor = class _ImageExtractor {
 };
 
 // src/utils/docling-result-downloader.ts
-var import_node_fs3 = require("fs");
+var import_node_fs5 = require("fs");
 var import_promises4 = require("fs/promises");
 var import_promises5 = require("stream/promises");
 async function downloadTaskResult(client, taskId, zipPath, logger, logPrefix) {
@@ -1824,7 +2189,7 @@ ${logPrefix} Task completed, downloading ZIP file...`);
   const zipResult = await client.getTaskResultFile(taskId);
   logger.info(`${logPrefix} Saving ZIP file to:`, zipPath);
   if (zipResult.fileStream) {
-    const writeStream = (0, import_node_fs3.createWriteStream)(zipPath);
+    const writeStream = (0, import_node_fs5.createWriteStream)(zipPath);
     await (0, import_promises5.pipeline)(zipResult.fileStream, writeStream);
     return;
   }
@@ -1849,9 +2214,9 @@ ${logPrefix} Task completed, downloading ZIP file...`);
 }
 
 // src/utils/local-file-server.ts
-var import_node_fs4 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_http = require("http");
-var import_node_path4 = require("path");
+var import_node_path5 = require("path");
 var LocalFileServer = class {
   server = null;
   port = 0;
@@ -1862,8 +2227,8 @@ var LocalFileServer = class {
    * @returns URL to access the file
    */
   async start(filePath) {
-    const filename = (0, import_node_path4.basename)(filePath);
-    const stat = (0, import_node_fs4.statSync)(filePath);
+    const filename = (0, import_node_path5.basename)(filePath);
+    const stat = (0, import_node_fs6.statSync)(filePath);
     return new Promise((resolve, reject) => {
       this.server = (0, import_node_http.createServer)((req, res) => {
         if (req.url === `/${filename}`) {
@@ -1871,7 +2236,7 @@ var LocalFileServer = class {
             "Content-Type": "application/pdf",
             "Content-Length": stat.size
           });
-          (0, import_node_fs4.createReadStream)(filePath).pipe(res);
+          (0, import_node_fs6.createReadStream)(filePath).pipe(res);
         } else {
           res.writeHead(404);
           res.end("Not Found");
@@ -1910,130 +2275,6 @@ var LocalFileServer = class {
 // src/utils/page-image-updater.ts
 var import_promises6 = require("fs/promises");
 var import_node_path6 = require("path");
-
-// src/processors/page-renderer.ts
-var import_node_fs5 = require("fs");
-var import_node_path5 = require("path");
-var PROGRESS_LOG_PERCENT_STEP = 10;
-var PageRenderer = class {
-  constructor(logger) {
-    this.logger = logger;
-  }
-  lastLoggedPercent = 0;
-  /**
-   * Render all pages of a PDF to individual PNG files.
-   *
-   * Uses per-page rendering (`magick 'input.pdf[N]'`) when page count is known,
-   * limiting peak memory to ~15MB/page instead of loading all pages at once.
-   *
-   * @param pdfPath - Absolute path to the source PDF file
-   * @param outputDir - Directory where pages/ subdirectory will be created
-   * @param options - Rendering options
-   * @returns Render result with page count and file paths
-   */
-  async renderPages(pdfPath, outputDir, options) {
-    const dpi = options?.dpi ?? PAGE_RENDERING.DEFAULT_DPI;
-    const pagesDir = (0, import_node_path5.join)(outputDir, "pages");
-    if (!(0, import_node_fs5.existsSync)(pagesDir)) {
-      (0, import_node_fs5.mkdirSync)(pagesDir, { recursive: true });
-    }
-    const totalPages = await this.getPageCount(pdfPath);
-    if (totalPages > 0) {
-      this.logger.info(
-        `[PageRenderer] Rendering ${totalPages} pages at ${dpi} DPI...`
-      );
-      this.lastLoggedPercent = 0;
-      for (let i = 0; i < totalPages; i++) {
-        const result = await spawnAsync(
-          "magick",
-          [
-            "-density",
-            dpi.toString(),
-            `${pdfPath}[${i}]`,
-            "-background",
-            "white",
-            "-alpha",
-            "remove",
-            "-alpha",
-            "off",
-            (0, import_node_path5.join)(pagesDir, `page_${i}.png`)
-          ],
-          { captureStdout: false }
-        );
-        if (result.code !== 0) {
-          throw new Error(
-            `[PageRenderer] Failed to render page ${i + 1}/${totalPages}: ${result.stderr || "Unknown error"}`
-          );
-        }
-        this.logProgress(i + 1, totalPages);
-      }
-    } else {
-      this.logger.info(`[PageRenderer] Rendering PDF at ${dpi} DPI...`);
-      const result = await spawnAsync(
-        "magick",
-        [
-          "-density",
-          dpi.toString(),
-          pdfPath,
-          "-background",
-          "white",
-          "-alpha",
-          "remove",
-          "-alpha",
-          "off",
-          (0, import_node_path5.join)(pagesDir, "page_%d.png")
-        ],
-        { captureStdout: false }
-      );
-      if (result.code !== 0) {
-        throw new Error(
-          `[PageRenderer] Failed to render PDF pages: ${result.stderr || "Unknown error"}`
-        );
-      }
-    }
-    const pageFiles = (0, import_node_fs5.readdirSync)(pagesDir).filter((f) => f.startsWith("page_") && f.endsWith(".png")).sort((a, b) => {
-      const numA = parseInt(a.replace("page_", "").replace(".png", ""), 10);
-      const numB = parseInt(b.replace("page_", "").replace(".png", ""), 10);
-      return numA - numB;
-    }).map((f) => (0, import_node_path5.join)(pagesDir, f));
-    this.logger.info(
-      `[PageRenderer] Rendered ${pageFiles.length} pages to ${pagesDir}`
-    );
-    return {
-      pageCount: pageFiles.length,
-      pagesDir,
-      pageFiles
-    };
-  }
-  /**
-   * Log rendering progress at appropriate intervals (every 10%).
-   */
-  logProgress(current, total) {
-    const percent = Math.floor(current / total * 100);
-    if (percent >= this.lastLoggedPercent + PROGRESS_LOG_PERCENT_STEP || current === total) {
-      this.lastLoggedPercent = percent;
-      this.logger.info(
-        `[PageRenderer] Rendering pages: ${current}/${total} (${percent}%)`
-      );
-    }
-  }
-  /**
-   * Get total page count using pdfinfo.
-   * Returns 0 on failure (progress logging will be skipped).
-   */
-  async getPageCount(pdfPath) {
-    try {
-      const result = await spawnAsync("pdfinfo", [pdfPath]);
-      if (result.code !== 0) return 0;
-      const match = result.stdout.match(/^Pages:\s+(\d+)/m);
-      return match ? parseInt(match[1], 10) : 0;
-    } catch {
-      return 0;
-    }
-  }
-};
-
-// src/utils/page-image-updater.ts
 async function renderAndUpdatePageImages(pdfPath, outputDir, logger, logPrefix) {
   logger.info(`${logPrefix} Rendering page images with ImageMagick...`);
   const renderer = new PageRenderer(logger);
@@ -2145,6 +2386,7 @@ ${logPrefix} Task failed after ${elapsed}s: ${errorDetails}`
 // src/core/conversion-options-builder.ts
 var import_es_toolkit = require("es-toolkit");
 function buildConversionOptions(options) {
+  const ocrLanguages = options.ocr_lang ?? DEFAULT_OCR_LANGUAGES;
   return {
     ...(0, import_es_toolkit.omit)(options, [
       "num_threads",
@@ -2157,14 +2399,18 @@ function buildConversionOptions(options) {
       "chunkedConversion",
       "chunkSize",
       "chunkMaxRetries",
-      "documentValidationModel"
+      "documentValidationModel",
+      "languageDetectionModel"
     ]),
     to_formats: ["json", "html"],
     image_export_mode: "embedded",
+    // Docling currently reads this top-level field in addition to ocr_options.
+    // Keep it populated even when language detection is skipped.
+    ocr_lang: ocrLanguages,
     ocr_engine: "ocrmac",
     ocr_options: {
       kind: "ocrmac",
-      lang: options.ocr_lang ?? ["ko-KR", "en-US"],
+      lang: ocrLanguages,
       recognition: "accurate",
       framework: "livetext"
     },
@@ -2237,7 +2483,7 @@ var ChunkedPDFConverter = class {
         const [start, end] = chunks[i];
         this.checkAbort(abortSignal);
         const chunkDir = (0, import_node_path7.join)(chunksBaseDir, `_chunk_${i}`);
-        (0, import_node_fs6.mkdirSync)(chunkDir, { recursive: true });
+        (0, import_node_fs7.mkdirSync)(chunkDir, { recursive: true });
         const doc = await this.convertChunk(
           i,
           chunks.length,
@@ -2266,12 +2512,12 @@ var ChunkedPDFConverter = class {
     this.logger.info(
       `[ChunkedPDFConverter] Merged: ${merged.texts.length} texts, ${merged.pictures.length} pictures, ${merged.tables.length} tables, ${Object.keys(merged.pages).length} pages`
     );
-    (0, import_node_fs6.mkdirSync)(outputDir, { recursive: true });
+    (0, import_node_fs7.mkdirSync)(outputDir, { recursive: true });
     const imagesDir = (0, import_node_path7.join)(outputDir, "images");
-    (0, import_node_fs6.mkdirSync)(imagesDir, { recursive: true });
+    (0, import_node_fs7.mkdirSync)(imagesDir, { recursive: true });
     this.relocateImages(chunksBaseDir, chunks.length, imagesDir);
     const resultPath = (0, import_node_path7.join)(outputDir, "result.json");
-    (0, import_node_fs6.writeFileSync)(resultPath, JSON.stringify(merged));
+    (0, import_node_fs7.writeFileSync)(resultPath, JSON.stringify(merged));
     try {
       await renderAndUpdatePageImages(
         pdfPath,
@@ -2286,16 +2532,16 @@ var ChunkedPDFConverter = class {
       );
       await onComplete(outputDir);
     } finally {
-      if ((0, import_node_fs6.existsSync)(chunksBaseDir)) {
-        (0, import_node_fs6.rmSync)(chunksBaseDir, { recursive: true, force: true });
+      if ((0, import_node_fs7.existsSync)(chunksBaseDir)) {
+        (0, import_node_fs7.rmSync)(chunksBaseDir, { recursive: true, force: true });
       }
       if (cleanupAfterCallback) {
         this.logger.info(
           "[ChunkedPDFConverter] Cleaning up output directory:",
           outputDir
         );
-        if ((0, import_node_fs6.existsSync)(outputDir)) {
-          (0, import_node_fs6.rmSync)(outputDir, { recursive: true, force: true });
+        if ((0, import_node_fs7.existsSync)(outputDir)) {
+          (0, import_node_fs7.rmSync)(outputDir, { recursive: true, force: true });
         }
       } else {
         this.logger.info(
@@ -2370,9 +2616,9 @@ var ChunkedPDFConverter = class {
       );
       const resultJsonPath = (0, import_node_path7.join)(chunkOutputDir, "result.json");
       const doc = await runJqFileJson(".", resultJsonPath);
-      if ((0, import_node_fs6.existsSync)(zipPath)) (0, import_node_fs6.rmSync)(zipPath, { force: true });
-      if ((0, import_node_fs6.existsSync)(extractDir)) {
-        (0, import_node_fs6.rmSync)(extractDir, { recursive: true, force: true });
+      if ((0, import_node_fs7.existsSync)(zipPath)) (0, import_node_fs7.rmSync)(zipPath, { force: true });
+      if ((0, import_node_fs7.existsSync)(extractDir)) {
+        (0, import_node_fs7.rmSync)(extractDir, { recursive: true, force: true });
       }
       const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
       if (attempt > 0) {
@@ -2440,8 +2686,8 @@ var ChunkedPDFConverter = class {
         "output",
         "images"
       );
-      if (!(0, import_node_fs6.existsSync)(chunkImagesDir)) continue;
-      const picFiles = (0, import_node_fs6.readdirSync)(chunkImagesDir).filter((f) => f.startsWith("pic_") && f.endsWith(".png")).sort((a, b) => {
+      if (!(0, import_node_fs7.existsSync)(chunkImagesDir)) continue;
+      const picFiles = (0, import_node_fs7.readdirSync)(chunkImagesDir).filter((f) => f.startsWith("pic_") && f.endsWith(".png")).sort((a, b) => {
         const numA = parseInt(a.replace("pic_", "").replace(".png", ""), 10);
         const numB = parseInt(b.replace("pic_", "").replace(".png", ""), 10);
         return numA - numB;
@@ -2449,7 +2695,7 @@ var ChunkedPDFConverter = class {
       for (let fileIdx = 0; fileIdx < picFiles.length; fileIdx++) {
         const src = (0, import_node_path7.join)(chunkImagesDir, picFiles[fileIdx]);
         const dest = (0, import_node_path7.join)(imagesDir, `pic_${picGlobalIndex + fileIdx}.png`);
-        (0, import_node_fs6.copyFileSync)(src, dest);
+        (0, import_node_fs7.copyFileSync)(src, dest);
       }
       picGlobalIndex += picFiles.length;
     }
@@ -2461,8 +2707,8 @@ var ChunkedPDFConverter = class {
         "output",
         "images"
       );
-      if (!(0, import_node_fs6.existsSync)(chunkImagesDir)) continue;
-      const imageFiles = (0, import_node_fs6.readdirSync)(chunkImagesDir).filter((f) => f.startsWith("image_") && f.endsWith(".png")).sort((a, b) => {
+      if (!(0, import_node_fs7.existsSync)(chunkImagesDir)) continue;
+      const imageFiles = (0, import_node_fs7.readdirSync)(chunkImagesDir).filter((f) => f.startsWith("image_") && f.endsWith(".png")).sort((a, b) => {
         const numA = parseInt(
           a.replace("image_", "").replace(".png", ""),
           10
@@ -2476,7 +2722,7 @@ var ChunkedPDFConverter = class {
       for (let fileIdx = 0; fileIdx < imageFiles.length; fileIdx++) {
         const src = (0, import_node_path7.join)(chunkImagesDir, imageFiles[fileIdx]);
         const dest = (0, import_node_path7.join)(imagesDir, `image_${imageGlobalIndex + fileIdx}.png`);
-        (0, import_node_fs6.copyFileSync)(src, dest);
+        (0, import_node_fs7.copyFileSync)(src, dest);
       }
       imageGlobalIndex += imageFiles.length;
     }
@@ -2491,18 +2737,18 @@ var ChunkedPDFConverter = class {
    * pages/page_N.png, these pic_ files become orphaned.
    */
   cleanupOrphanedPicFiles(resultPath, imagesDir) {
-    const content = (0, import_node_fs6.readFileSync)(resultPath, "utf-8");
+    const content = (0, import_node_fs7.readFileSync)(resultPath, "utf-8");
     const referencedPics = new Set(
       [...content.matchAll(/images\/pic_\d+\.png/g)].map(
         (m) => m[0].replace("images/", "")
       )
     );
-    const picFiles = (0, import_node_fs6.readdirSync)(imagesDir).filter(
+    const picFiles = (0, import_node_fs7.readdirSync)(imagesDir).filter(
       (f) => f.startsWith("pic_") && f.endsWith(".png")
     );
     const orphanedFiles = picFiles.filter((file) => !referencedPics.has(file));
     orphanedFiles.forEach((file) => {
-      (0, import_node_fs6.rmSync)((0, import_node_path7.join)(imagesDir, file), { force: true });
+      (0, import_node_fs7.rmSync)((0, import_node_path7.join)(imagesDir, file), { force: true });
     });
     if (orphanedFiles.length > 0) {
       this.logger.info(
@@ -2519,7 +2765,7 @@ var ChunkedPDFConverter = class {
     let cumulative = 0;
     for (let i = 0; i < totalChunks; i++) {
       const dir = (0, import_node_path7.join)(chunksBaseDir, `_chunk_${i}`, "output", "images");
-      const count = (0, import_node_fs6.existsSync)(dir) ? (0, import_node_fs6.readdirSync)(dir).filter(
+      const count = (0, import_node_fs7.existsSync)(dir) ? (0, import_node_fs7.readdirSync)(dir).filter(
         (f) => f.startsWith("pic_") && f.endsWith(".png")
       ).length : 0;
       offsets.push(cumulative);
@@ -2538,7 +2784,7 @@ var ChunkedPDFConverter = class {
 };
 
 // src/core/docling-conversion-executor.ts
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_path8 = require("path");
 var DoclingConversionExecutor = class {
   constructor(logger, client, timeout) {
@@ -2631,19 +2877,19 @@ var DoclingConversionExecutor = class {
       this.logger.info("[PDFConverter] Total time:", duration, "ms");
     } finally {
       this.logger.info("[PDFConverter] Cleaning up temporary files...");
-      if ((0, import_node_fs7.existsSync)(zipPath)) {
-        (0, import_node_fs7.rmSync)(zipPath, { force: true });
+      if ((0, import_node_fs8.existsSync)(zipPath)) {
+        (0, import_node_fs8.rmSync)(zipPath, { force: true });
       }
-      if ((0, import_node_fs7.existsSync)(extractDir)) {
-        (0, import_node_fs7.rmSync)(extractDir, { recursive: true, force: true });
+      if ((0, import_node_fs8.existsSync)(extractDir)) {
+        (0, import_node_fs8.rmSync)(extractDir, { recursive: true, force: true });
       }
       if (cleanupAfterCallback) {
         this.logger.info(
           "[PDFConverter] Cleaning up output directory:",
           outputDir
         );
-        if ((0, import_node_fs7.existsSync)(outputDir)) {
-          (0, import_node_fs7.rmSync)(outputDir, { recursive: true, force: true });
+        if ((0, import_node_fs8.existsSync)(outputDir)) {
+          (0, import_node_fs8.rmSync)(outputDir, { recursive: true, force: true });
         }
       } else {
         this.logger.info("[PDFConverter] Output preserved at:", outputDir);
@@ -2701,7 +2947,7 @@ var DoclingConversionExecutor = class {
 };
 
 // src/core/image-pdf-converter.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_os2 = require("os");
 var import_node_path9 = require("path");
 var ImagePdfConverter = class {
@@ -2729,8 +2975,8 @@ var ImagePdfConverter = class {
       this.logger.info("[ImagePdfConverter] Image PDF created:", outputPath);
       return outputPath;
     } finally {
-      if ((0, import_node_fs8.existsSync)(inputPath)) {
-        (0, import_node_fs8.rmSync)(inputPath, { force: true });
+      if ((0, import_node_fs9.existsSync)(inputPath)) {
+        (0, import_node_fs9.rmSync)(inputPath, { force: true });
       }
     }
   }
@@ -2777,23 +3023,23 @@ var ImagePdfConverter = class {
    * Cleanup the temporary image PDF file
    */
   cleanup(imagePdfPath) {
-    if ((0, import_node_fs8.existsSync)(imagePdfPath)) {
+    if ((0, import_node_fs9.existsSync)(imagePdfPath)) {
       this.logger.info(
         "[ImagePdfConverter] Cleaning up temp file:",
         imagePdfPath
       );
-      (0, import_node_fs8.rmSync)(imagePdfPath, { force: true });
+      (0, import_node_fs9.rmSync)(imagePdfPath, { force: true });
     }
   }
 };
 
 // src/core/post-docling-correction-pipeline.ts
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_path16 = require("path");
 
 // src/processors/post-docling-page-processor.ts
-var import_model = require("@heripo/model");
-var import_node_fs10 = require("fs");
+var import_model2 = require("@heripo/model");
+var import_node_fs11 = require("fs");
 var import_node_path11 = require("path");
 
 // src/prompts/text-correction-prompt.ts
@@ -2850,35 +3096,35 @@ Substitution rules for tc:
 If all correct: {"tc":[],"cc":[]}`;
 
 // src/types/vlm-text-correction-schema.ts
-var import_v4 = require("zod/v4");
-var vlmTextCorrectionSchema = import_v4.z.object({
+var import_v42 = require("zod/v4");
+var vlmTextCorrectionSchema = import_v42.z.object({
   /** Text element corrections (substitution-based) */
-  tc: import_v4.z.array(
-    import_v4.z.object({
+  tc: import_v42.z.array(
+    import_v42.z.object({
       /** Text element index (from prompt) */
-      i: import_v4.z.number().int().nonnegative(),
+      i: import_v42.z.number().int().nonnegative(),
       /** Substitutions: find/replace pairs applied left-to-right */
-      s: import_v4.z.array(
-        import_v4.z.object({
+      s: import_v42.z.array(
+        import_v42.z.object({
           /** Exact garbled substring to find */
-          f: import_v4.z.string(),
+          f: import_v42.z.string(),
           /** Corrected replacement text */
-          r: import_v4.z.string()
+          r: import_v42.z.string()
         })
       )
     })
   ),
   /** Table cell corrections */
-  cc: import_v4.z.array(
-    import_v4.z.object({
+  cc: import_v42.z.array(
+    import_v42.z.object({
       /** Table index (within the page) */
-      ti: import_v4.z.number().int().nonnegative(),
+      ti: import_v42.z.number().int().nonnegative(),
       /** Row index */
-      r: import_v4.z.number().int().nonnegative(),
+      r: import_v42.z.number().int().nonnegative(),
       /** Column index */
-      c: import_v4.z.number().int().nonnegative(),
+      c: import_v42.z.number().int().nonnegative(),
       /** Corrected cell text */
-      t: import_v4.z.string()
+      t: import_v42.z.string()
     })
   )
 });
@@ -3016,21 +3262,21 @@ function applyCorrections(doc, pageNo, corrections, logger) {
 }
 
 // src/processors/review-assistance/review-assistance-page-gate.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_path10 = require("path");
-var import_v42 = require("zod/v4");
+var import_v43 = require("zod/v4");
 var REVIEW_ASSISTANCE_PAGE_GATE_FILE = "review_assistance_page_gate.json";
 var REVIEW_ASSISTANCE_PAGE_GATE_MAX_RETRIES = 2;
 var REVIEW_ASSISTANCE_PAGE_GATE_TEMPERATURE = 0;
 var MAX_REASON_COUNT = 12;
 var MAX_CONTEXT_TEXT_LENGTH = 1800;
 var REVIEW_ASSISTANCE_PAGE_IMAGE_NOT_AVAILABLE_REASON = "page_image_not_available";
-var reviewAssistancePageGateSchema = import_v42.z.object({
-  eligible: import_v42.z.boolean(),
-  kind: import_v42.z.enum(["toc", "archaeological_data", "non_meaningful"]),
-  score: import_v42.z.number().min(0).max(100),
-  reasons: import_v42.z.array(import_v42.z.string()).max(MAX_REASON_COUNT),
-  exclusionReasons: import_v42.z.array(import_v42.z.string()).max(MAX_REASON_COUNT)
+var reviewAssistancePageGateSchema = import_v43.z.object({
+  eligible: import_v43.z.boolean(),
+  kind: import_v43.z.enum(["toc", "archaeological_data", "non_meaningful"]),
+  score: import_v43.z.number().min(0).max(100),
+  reasons: import_v43.z.array(import_v43.z.string()).max(MAX_REASON_COUNT),
+  exclusionReasons: import_v43.z.array(import_v43.z.string()).max(MAX_REASON_COUNT)
 });
 var REVIEW_ASSISTANCE_PAGE_GATE_PROMPT = `You are deciding whether a single PDF page should run structural Review Assistance after OCR text correction.
 
@@ -3165,9 +3411,9 @@ function isReviewAssistancePageGatePending(eligibility) {
 }
 function readReviewAssistancePageGateReport(outputDir) {
   const path = (0, import_node_path10.join)(outputDir, REVIEW_ASSISTANCE_PAGE_GATE_FILE);
-  if (!(0, import_node_fs9.existsSync)(path)) return void 0;
+  if (!(0, import_node_fs10.existsSync)(path)) return void 0;
   const report = JSON.parse(
-    (0, import_node_fs9.readFileSync)(path, "utf-8")
+    (0, import_node_fs10.readFileSync)(path, "utf-8")
   );
   return new Map(report.pages.map((page) => [page.pageNo, page]));
 }
@@ -3177,7 +3423,7 @@ function writeReviewAssistancePageGateReport(outputDir, pages) {
     version: "1.0",
     pages: [...pages].sort((a, b) => a.pageNo - b.pageNo)
   };
-  (0, import_node_fs9.writeFileSync)(
+  (0, import_node_fs10.writeFileSync)(
     (0, import_node_path10.join)(outputDir, REVIEW_ASSISTANCE_PAGE_GATE_FILE),
     JSON.stringify(report, null, 2)
   );
@@ -3185,7 +3431,7 @@ function writeReviewAssistancePageGateReport(outputDir, pages) {
 
 // src/processors/post-docling-page-processor.ts
 var DEFAULT_CONCURRENCY = 1;
-var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_MAX_RETRIES2 = 3;
 var DEFAULT_TEMPERATURE = 0;
 var PostDoclingPageProcessor = class {
   constructor(logger) {
@@ -3203,7 +3449,7 @@ var PostDoclingPageProcessor = class {
   async correctAndSave(outputDir, model, options) {
     this.logger.info("[PostDoclingPageProcessor] Starting text correction...");
     const resultPath = (0, import_node_path11.join)(outputDir, "result.json");
-    const doc = JSON.parse((0, import_node_fs10.readFileSync)(resultPath, "utf-8"));
+    const doc = JSON.parse((0, import_node_fs11.readFileSync)(resultPath, "utf-8"));
     const allPageNumbers = this.getPageNumbers(doc);
     if (allPageNumbers.length === 0) {
       this.logger.info("[PostDoclingPageProcessor] No pages to process");
@@ -3247,7 +3493,7 @@ var PostDoclingPageProcessor = class {
       if (corrections === null) return;
       applyCorrections(doc, pageNo, corrections, this.logger);
     });
-    (0, import_node_fs10.writeFileSync)(resultPath, JSON.stringify(doc, null, 2));
+    (0, import_node_fs11.writeFileSync)(resultPath, JSON.stringify(doc, null, 2));
     const gateResults = results.map((result) => result.reviewAssistanceEligibility).filter(
       (result) => result !== void 0
     );
@@ -3345,7 +3591,7 @@ var PostDoclingPageProcessor = class {
           }
         ],
         primaryModel: model,
-        maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES,
+        maxRetries: options?.maxRetries ?? DEFAULT_MAX_RETRIES2,
         temperature: options?.temperature ?? DEFAULT_TEMPERATURE,
         abortSignal: options?.abortSignal,
         component: "PostDoclingPageProcessor",
@@ -3482,7 +3728,7 @@ var PostDoclingPageProcessor = class {
     if (!documentLanguages?.length) {
       return TEXT_CORRECTION_SYSTEM_PROMPT;
     }
-    const languageDesc = (0, import_model.buildLanguageDescription)(documentLanguages);
+    const languageDesc = (0, import_model2.buildLanguageDescription)(documentLanguages);
     const prefix = `LANGUAGE CONTEXT: This document is ${languageDesc}. Focus on correcting characters that do not match this language.
 
 `;
@@ -3511,21 +3757,21 @@ var PostDoclingPageProcessor = class {
    */
   readPageImage(outputDir, pageNo) {
     const imagePath = (0, import_node_path11.join)(outputDir, "pages", `page_${pageNo - 1}.png`);
-    return new Uint8Array((0, import_node_fs10.readFileSync)(imagePath));
+    return new Uint8Array((0, import_node_fs11.readFileSync)(imagePath));
   }
 };
 
 // src/processors/review-assistance/review-assistance-runner.ts
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_promises7 = require("fs/promises");
 var import_node_path15 = require("path");
 
 // src/types/review-assistance-schema.ts
-var import_v43 = require("zod/v4");
+var import_v44 = require("zod/v4");
 var REVIEW_ASSISTANCE_RATIONALE_MAX_LENGTH = 2e3;
 var REVIEW_ASSISTANCE_EVIDENCE_MAX_LENGTH = 2e3;
 var REVIEW_ASSISTANCE_PAGE_NOTE_MAX_LENGTH = 2e3;
-var reviewAssistanceCommandOpSchema = import_v43.z.enum([
+var reviewAssistanceCommandOpSchema = import_v44.z.enum([
   "replaceText",
   "addText",
   "updateTextRole",
@@ -3543,18 +3789,18 @@ var reviewAssistanceCommandOpSchema = import_v43.z.enum([
   "linkFootnote",
   "moveNode"
 ]);
-var reviewAssistanceRawCommandSchema = import_v43.z.object({
+var reviewAssistanceRawCommandSchema = import_v44.z.object({
   op: reviewAssistanceCommandOpSchema,
-  targetRef: import_v43.z.string().nullable(),
-  payload: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()),
-  confidence: import_v43.z.number().min(0).max(1),
-  rationale: import_v43.z.string().max(REVIEW_ASSISTANCE_RATIONALE_MAX_LENGTH),
-  evidence: import_v43.z.string().max(REVIEW_ASSISTANCE_EVIDENCE_MAX_LENGTH).nullable()
+  targetRef: import_v44.z.string().nullable(),
+  payload: import_v44.z.record(import_v44.z.string(), import_v44.z.unknown()),
+  confidence: import_v44.z.number().min(0).max(1),
+  rationale: import_v44.z.string().max(REVIEW_ASSISTANCE_RATIONALE_MAX_LENGTH),
+  evidence: import_v44.z.string().max(REVIEW_ASSISTANCE_EVIDENCE_MAX_LENGTH).nullable()
 });
-var reviewAssistancePageSchema = import_v43.z.object({
-  pageNo: import_v43.z.number().int().positive(),
-  commands: import_v43.z.array(reviewAssistanceRawCommandSchema).max(80),
-  pageNotes: import_v43.z.array(import_v43.z.string().max(REVIEW_ASSISTANCE_PAGE_NOTE_MAX_LENGTH)).max(10)
+var reviewAssistancePageSchema = import_v44.z.object({
+  pageNo: import_v44.z.number().int().positive(),
+  commands: import_v44.z.array(reviewAssistanceRawCommandSchema).max(80),
+  pageNotes: import_v44.z.array(import_v44.z.string().max(REVIEW_ASSISTANCE_PAGE_NOTE_MAX_LENGTH)).max(10)
 });
 
 // src/prompts/review-assistance-prompt.ts
@@ -5047,7 +5293,7 @@ var PictureSplitCandidateDetector = class {
 };
 
 // src/processors/review-assistance/review-assistance-checkpoint-store.ts
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_path13 = require("path");
 var CHECKPOINT_FILE = "review_assistance_checkpoint.json";
 var ReviewAssistanceCheckpointStore = class _ReviewAssistanceCheckpointStore {
@@ -5121,15 +5367,15 @@ var ReviewAssistanceCheckpointStore = class _ReviewAssistanceCheckpointStore {
   }
   write() {
     this.checkpoint.updatedAt = this.now().toISOString();
-    (0, import_node_fs11.writeFileSync)(this.path, JSON.stringify(this.checkpoint, null, 2));
+    (0, import_node_fs12.writeFileSync)(this.path, JSON.stringify(this.checkpoint, null, 2));
   }
   static read(path, runId, now) {
-    if (!(0, import_node_fs11.existsSync)(path)) {
+    if (!(0, import_node_fs12.existsSync)(path)) {
       return this.empty(runId, now);
     }
     try {
       const parsed = JSON.parse(
-        (0, import_node_fs11.readFileSync)(path, "utf-8")
+        (0, import_node_fs12.readFileSync)(path, "utf-8")
       );
       if (parsed.schemaVersion !== 1 || parsed.runId !== runId) {
         return this.empty(runId, now);
@@ -5419,10 +5665,10 @@ var ReviewAssistanceContextPacker = class {
 };
 
 // src/processors/review-assistance/review-assistance-patcher.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 
 // src/processors/review-assistance/image-crop-writer.ts
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_node_path14 = require("path");
 var ImageCropWriter = class {
   constructor(logger, snapper) {
@@ -5432,13 +5678,13 @@ var ImageCropWriter = class {
   snapper;
   async writeCrop(input) {
     const imagesDir = (0, import_node_path14.join)(input.outputDir, "images");
-    if (!(0, import_node_fs12.existsSync)(imagesDir)) {
-      (0, import_node_fs12.mkdirSync)(imagesDir, { recursive: true });
+    if (!(0, import_node_fs13.existsSync)(imagesDir)) {
+      (0, import_node_fs13.mkdirSync)(imagesDir, { recursive: true });
     }
     const filename = this.buildFilename(input);
     const imageUri = `images/${filename}`;
     const outputPath = (0, import_node_path14.join)(input.outputDir, imageUri);
-    if ((0, import_node_fs12.existsSync)(outputPath)) {
+    if ((0, import_node_fs13.existsSync)(outputPath)) {
       return { imageUri, outputPath, created: false };
     }
     const dims = await this.snapper.getImageDimensions(input.pageImagePath);
@@ -5461,7 +5707,7 @@ var ImageCropWriter = class {
       outputPath
     ]);
     if (result.code !== 0) {
-      (0, import_node_fs12.rmSync)(outputPath, { force: true });
+      (0, import_node_fs13.rmSync)(outputPath, { force: true });
       throw new Error(
         `[ImageCropWriter] Failed to write crop: ${result.stderr || "Unknown error"}`
       );
@@ -6331,7 +6577,7 @@ var ReviewAssistancePatcher = class {
   removeFiles(paths) {
     for (const path of paths) {
       try {
-        (0, import_node_fs13.rmSync)(path, { force: true });
+        (0, import_node_fs14.rmSync)(path, { force: true });
       } catch (error) {
         this.logger.warn(
           `[ReviewAssistancePatcher] Failed to remove generated artifact ${path}`,
@@ -7911,14 +8157,14 @@ var ReviewAssistanceRunner = class {
     const resultPath = (0, import_node_path15.join)(outputDir, "result.json");
     const ocrOriginPath = (0, import_node_path15.join)(outputDir, "result_ocr_origin.json");
     const reviewOriginPath = (0, import_node_path15.join)(outputDir, "result_review_origin.json");
-    if (!(0, import_node_fs14.existsSync)(reviewOriginPath)) {
-      (0, import_node_fs14.copyFileSync)(resultPath, reviewOriginPath);
+    if (!(0, import_node_fs15.existsSync)(reviewOriginPath)) {
+      (0, import_node_fs15.copyFileSync)(resultPath, reviewOriginPath);
     }
-    if (!(0, import_node_fs14.existsSync)(ocrOriginPath)) {
-      (0, import_node_fs14.copyFileSync)(reviewOriginPath, ocrOriginPath);
+    if (!(0, import_node_fs15.existsSync)(ocrOriginPath)) {
+      (0, import_node_fs15.copyFileSync)(reviewOriginPath, ocrOriginPath);
     }
     const doc = JSON.parse(
-      (0, import_node_fs14.readFileSync)(reviewOriginPath, "utf-8")
+      (0, import_node_fs15.readFileSync)(reviewOriginPath, "utf-8")
     );
     const pageTexts = options.pageTexts ?? await PdfTextExtractor.tryExtract(
       this.logger,
@@ -8017,7 +8263,7 @@ var ReviewAssistanceRunner = class {
       outputDir,
       contexts
     });
-    (0, import_node_fs14.writeFileSync)(resultPath, JSON.stringify(patched.doc, null, 2));
+    (0, import_node_fs15.writeFileSync)(resultPath, JSON.stringify(patched.doc, null, 2));
     this.emitProgress(options, {
       substage: "review-assistance:patch",
       status: "completed",
@@ -8048,7 +8294,7 @@ var ReviewAssistanceRunner = class {
       reportId,
       pageCount: contexts.length
     });
-    (0, import_node_fs14.writeFileSync)(
+    (0, import_node_fs15.writeFileSync)(
       (0, import_node_path15.join)(outputDir, "review_assistance.json"),
       JSON.stringify(report, null, 2)
     );
@@ -9335,7 +9581,7 @@ var PostDoclingCorrectionPipeline = class {
       const pageTexts = await this.extractPageTexts(pdfPath, outputDir);
       const resultPath = (0, import_node_path16.join)(outputDir, "result.json");
       const ocrOriginPath = (0, import_node_path16.join)(outputDir, "result_ocr_origin.json");
-      (0, import_node_fs15.copyFileSync)(resultPath, ocrOriginPath);
+      (0, import_node_fs16.copyFileSync)(resultPath, ocrOriginPath);
       const pageProcessor = new PostDoclingPageProcessor(this.logger);
       await pageProcessor.correctAndSave(
         outputDir,
@@ -9441,8 +9687,13 @@ var PDFConverter = class {
   async convert(url, reportId, onComplete, cleanupAfterCallback, options, abortSignal) {
     this.logger.info("[PDFConverter] Converting:", url);
     const aggregator = options.aggregator ?? new LLMTokenUsageAggregator();
-    const trackedOptions = { ...options, aggregator };
     const pdfPath = url.startsWith("file://") ? url.slice(7) : void 0;
+    const trackedOptions = await this.withDetectedLanguages(
+      pdfPath,
+      reportId,
+      { ...options, aggregator },
+      abortSignal
+    );
     const correctedOnComplete = new PostDoclingCorrectionPipeline(
       this.logger
     ).wrapCallback(pdfPath, reportId, trackedOptions, onComplete, abortSignal);
@@ -9505,6 +9756,58 @@ var PDFConverter = class {
     }
     return this.buildTokenReport(aggregator) ?? conversionReport;
   }
+  async withDetectedLanguages(pdfPath, reportId, options, abortSignal) {
+    if (options.ocr_lang && options.ocr_lang.length > 0) {
+      this.logger.info(
+        `[PDFConverter] OCR languages provided: ${JSON.stringify(options.ocr_lang)}`
+      );
+      return options;
+    }
+    if (!pdfPath) {
+      this.logger.info(
+        "[PDFConverter] Local PDF not available; OCR languages will use defaults"
+      );
+      return {
+        ...options,
+        ocr_lang: [...DEFAULT_OCR_LANGUAGES]
+      };
+    }
+    const languageDetectionDir = (0, import_node_path17.join)(
+      process.cwd(),
+      "output",
+      reportId,
+      "_language_detection"
+    );
+    const detector = new PdfLanguageDetector(
+      this.logger,
+      new PageRenderer(this.logger),
+      new PdfTextExtractor(this.logger)
+    );
+    try {
+      const result = await detector.detect(pdfPath, languageDetectionDir, {
+        model: options.languageDetectionModel,
+        aggregator: options.aggregator,
+        abortSignal
+      });
+      this.logger.info(
+        `[PDFConverter] OCR languages detected: ${JSON.stringify(result.detectedLanguages)} (${result.reason})`
+      );
+      if (options.onTokenUsage && options.aggregator) {
+        const tokenReport = this.buildTokenReport(options.aggregator);
+        if (tokenReport) {
+          options.onTokenUsage(tokenReport);
+        }
+      }
+      return {
+        ...options,
+        ocr_lang: result.detectedLanguages
+      };
+    } finally {
+      if ((0, import_node_fs17.existsSync)(languageDetectionDir)) {
+        (0, import_node_fs17.rmSync)(languageDetectionDir, { recursive: true, force: true });
+      }
+    }
+  }
   /**
    * Build a token usage report from the aggregator.
    * Returns null when no LLM calls were tracked.
@@ -9663,7 +9966,7 @@ var PDFParser = class {
       this.baseUrl = void 0;
     }
     this.timeout = timeout;
-    this.venvPath = venvPath || (0, import_node_path17.join)(process.cwd(), ".venv");
+    this.venvPath = venvPath || (0, import_node_path18.join)(process.cwd(), ".venv");
     this.killExistingProcess = killExistingProcess;
     this.enableImagePdfFallback = enableImagePdfFallback;
   }
@@ -9960,7 +10263,7 @@ var META_DESCRIPTION_PATTERNS_EN = [
 ];
 var REPETITIVE_PATTERN_RATIO_THRESHOLD = 0.3;
 var REPETITIVE_PATTERN_MIN_REPEATS = 5;
-var HANGUL_REGEX = /[\uAC00-\uD7AF\u1100-\u11FF]/g;
+var HANGUL_REGEX2 = /[\uAC00-\uD7AF\u1100-\u11FF]/g;
 var CJK_REGEX = /[\u4E00-\u9FFF]/g;
 var VlmResponseValidator = class {
   /**
@@ -10028,7 +10331,7 @@ var VlmResponseValidator = class {
     if (nonWhitespace.length < MIN_CONTENT_LENGTH) {
       return null;
     }
-    const hangulCount = allContent.match(HANGUL_REGEX)?.length ?? 0;
+    const hangulCount = allContent.match(HANGUL_REGEX2)?.length ?? 0;
     const cjkCount = allContent.match(CJK_REGEX)?.length ?? 0;
     const koreanCjkCount = hangulCount + cjkCount;
     const ratio = koreanCjkCount / nonWhitespace.length;