@arcships/light-ocr 0.4.0 → 0.5.1

package/package.json

@@ -7,7 +7,7 @@
   },
   "dependencies": {
     "@arcships/light-ocr-model-ppocrv6-small": "0.3.4",
-    "@arcships/light-ocr-runtime": "0.1.0"
+    "@arcships/light-ocr-runtime": "0.1.1"
   },
   "description": "Offline PP-OCRv6 Small OCR for Node.js — the stable default tier",
   "engines": {
@@ -31,6 +31,9 @@
   "main": "./src/index.cjs",
   "module": "./src/index.mjs",
   "name": "@arcships/light-ocr",
+  "optionalDependencies": {
+    "pdfium-native": "0.6.1"
+  },
   "publishConfig": {
     "access": "public",
     "provenance": true
@@ -41,5 +44,5 @@
   },
   "type": "commonjs",
   "types": "./src/index.d.ts",
-  "version": "0.4.0"
+  "version": "0.5.1"
 }

package/src/cli.cjs

@@ -1,9 +1,30 @@
 #!/usr/bin/env node
 'use strict';
 
+const path = require('node:path');
+
 const facade = require('./index.cjs');
-const { createCli } = require('@arcships/light-ocr-runtime/cli');
-const { coreVersion } = require('@arcships/light-ocr-runtime/metadata');
+
+// Try to use workspace dependencies, fallback to local paths
+let createCli, coreVersion, loadNative;
+try {
+  ({ createCli } = require('@arcships/light-ocr-runtime/cli'));
+  ({ coreVersion } = require('@arcships/light-ocr-runtime/metadata'));
+} catch {
+  // Fallback to local runtime
+  ({ createCli } = require(path.join(__dirname, '..', '..', 'runtime', 'src', 'cli.cjs')));
+  ({ coreVersion } = require(path.join(__dirname, '..', '..', 'runtime', 'src', 'metadata.cjs')));
+}
+try {
+  ({ loadNative } = require('@arcships/light-ocr-runtime'));
+} catch {
+  try {
+    ({ loadNative } = require(path.join(__dirname, '..', '..', 'runtime', 'src', 'load-native.cjs')));
+  } catch {
+    // loadNative unavailable — doctor will report native as unavailable
+  }
+}
+
 const packageMetadata = require('../package.json');
 
 const cli = createCli({
@@ -11,6 +32,7 @@ const cli = createCli({
   commandName: 'light-ocr',
   packageVersion: packageMetadata.version,
   coreVersion,
+  loadNative,
 });
 
 if (require.main === module) {

package/src/index.cjs

@@ -1,8 +1,20 @@
 'use strict';
 
-const { createModelFacade } = require('@arcships/light-ocr-runtime/facade');
+const path = require('node:path');
 
-module.exports = createModelFacade({
+// Try to use workspace dependencies, fallback to local paths
+let createModelFacade;
+try {
+  ({ createModelFacade } = require('@arcships/light-ocr-runtime/facade'));
+} catch {
+  // Fallback to local runtime
+  const facadePath = path.join(__dirname, '..', '..', 'runtime', 'src', 'facade.cjs');
+  ({ createModelFacade } = require(facadePath));
+}
+
+const fs = require('node:fs');
+
+const facade = createModelFacade({
   model: 'ppocrv6-small',
   modelPackage: '@arcships/light-ocr-model-ppocrv6-small',
   compatibleBundleIds: [
@@ -25,3 +37,250 @@ module.exports = createModelFacade({
     maturity: 'stable',
   },
 });
+
+// Lazy load pdfium-native
+let pdfium = null;
+let pdfiumLoaded = false;
+
+function loadPdfium() {
+  if (pdfiumLoaded) return pdfium;
+  pdfiumLoaded = true;
+  try {
+    pdfium = require('pdfium-native');
+  } catch {
+    pdfium = null;
+  }
+  return pdfium;
+}
+
+function hasPdfSupport() {
+  return loadPdfium() !== null;
+}
+
+async function* processPdf(engine, pdfBuffer, options = {}) {
+  const pdfiumNative = loadPdfium();
+  if (!pdfiumNative) {
+    throw new facade.OcrError('unsupported_capability', 'PDF support not available. Install pdfium-native.');
+  }
+
+  const {
+    pageRange,
+    dpi = 150,
+    maxPages = 100,
+    maxPagePixels = 4096 * 4096,
+    maxTotalPixels = 100 * 1024 * 1024,
+    maxFileBytes = 100 * 1024 * 1024,
+    signal,
+    ocrOptions = {}
+  } = options;
+
+  // Check file size
+  if (pdfBuffer.byteLength > maxFileBytes) {
+    throw new facade.OcrError('resource_limit_exceeded', 
+      `File size ${pdfBuffer.byteLength} exceeds maxFileBytes ${maxFileBytes}`);
+  }
+
+  let totalPixels = 0;
+
+  // Open PDF document
+  const doc = await pdfiumNative.loadDocument(pdfBuffer);
+  
+  try {
+    const pageCount = doc.pageCount;
+    
+    // Apply page range
+    const start = pageRange?.start ? Math.max(1, pageRange.start) : 1;
+    const end = pageRange?.end ? Math.min(pageCount, pageRange.end) : pageCount;
+    
+    // Check page limits
+    if (end - start + 1 > maxPages) {
+      throw new facade.OcrError('resource_limit_exceeded', 
+        `Page count ${end - start + 1} exceeds maxPages ${maxPages}`);
+    }
+
+    for (let i = start; i <= end; i++) {
+      // Check abort signal
+      if (signal?.aborted) {
+        throw new facade.OcrError('internal_error', 'Operation aborted');
+      }
+
+      const page = await doc.getPage(i - 1); // 0-indexed
+      
+      // Get page dimensions
+      const { width, height } = page;
+      const pagePixels = width * height;
+      
+      // Check pixel limits
+      if (pagePixels > maxPagePixels) {
+        throw new facade.OcrError('resource_limit_exceeded', 
+          `Page ${i} pixels ${pagePixels} exceeds maxPagePixels ${maxPagePixels}`);
+      }
+      
+      totalPixels += pagePixels;
+      if (totalPixels > maxTotalPixels) {
+        throw new facade.OcrError('resource_limit_exceeded', 
+          `Total pixels ${totalPixels} exceeds maxTotalPixels ${maxTotalPixels}`);
+      }
+
+      // Render page to PNG
+      const renderStart = Date.now();
+      const scale = dpi / 72; // PDF default is 72 DPI
+      const pngBuffer = await page.render({ scale });
+      const renderTime = (Date.now() - renderStart) * 1000;
+
+      // OCR the rendered image
+      const ocrStart = Date.now();
+      const ocrResult = await engine.recognizeEncoded(pngBuffer, ocrOptions);
+      const ocrTime = (Date.now() - ocrStart) * 1000;
+
+      // Close page to free native memory
+      await page.close();
+
+      // Build page result
+      const pageResult = {
+        index: i - 1,
+        width: ocrResult.imageWidth,
+        height: ocrResult.imageHeight,
+        coordinateSpace: 'pageSpace',
+        structure: 'ocr-order',
+        lines: ocrResult.lines.map((line, idx) => ({
+          id: `L${idx}`,
+          text: line.text,
+          confidence: line.confidence,
+          box: line.box
+        })),
+        source: {
+          kind: 'pdf',
+          mediaType: 'application/pdf',
+          identity: { pageIndex: i - 1 },
+          appliedTransforms: {
+            pdf: {
+              rotation: 0,
+              mediaBox: { x: 0, y: 0, width, height },
+              cropBox: { x: 0, y: 0, width, height },
+              dpi,
+              scale: dpi / 72
+            }
+          }
+        },
+        timingUs: {
+          total: renderTime + ocrTime,
+          decode: renderTime,
+          ocr: ocrTime
+        },
+        modelBundleId: ocrResult.modelBundleId
+      };
+
+      yield pageResult;
+    }
+  } finally {
+    doc.destroy();
+  }
+}
+
+async function* processImages(engine, imageBuffers, options = {}) {
+  const { signal, ocrOptions = {} } = options;
+
+  for (let i = 0; i < imageBuffers.length; i++) {
+    if (signal?.aborted) {
+      throw new facade.OcrError('internal_error', 'Operation aborted');
+    }
+
+    const buffer = imageBuffers[i];
+    
+    const ocrStart = Date.now();
+    const ocrResult = await engine.recognizeEncoded(buffer, {
+      ...ocrOptions,
+      applyExif: true
+    });
+    const ocrTime = (Date.now() - ocrStart) * 1000;
+
+    const pageResult = {
+      index: i,
+      width: ocrResult.imageWidth,
+      height: ocrResult.imageHeight,
+      coordinateSpace: 'pageSpace',
+      structure: 'ocr-order',
+      lines: ocrResult.lines.map((line, idx) => ({
+        id: `L${idx}`,
+        text: line.text,
+        confidence: line.confidence,
+        box: line.box
+      })),
+      source: {
+        kind: 'image',
+        mediaType: 'image/png',
+        identity: { index: i },
+        appliedTransforms: {
+          exif: { orientation: 1, applied: false }
+        }
+      },
+      timingUs: {
+        total: ocrTime,
+        decode: 0,
+        ocr: ocrTime
+      },
+      modelBundleId: ocrResult.modelBundleId
+    };
+
+    yield pageResult;
+  }
+}
+
+async function* recognizeDocument(source, options = {}) {
+  // Create engine if not provided
+  let engine = options.engine;
+  let engineCreated = false;
+  
+  if (!engine) {
+    engine = await facade.createEngine();
+    engineCreated = true;
+  }
+  
+  try {
+    let buffers;
+    let isPdf = false;
+    
+    if (Array.isArray(source)) {
+      // Multiple images
+      buffers = [];
+      for (const s of source) {
+        if (typeof s === 'string') {
+          buffers.push(fs.readFileSync(s));
+        } else {
+          buffers.push(s);
+        }
+      }
+    } else if (typeof source === 'string') {
+      // File path
+      const ext = path.extname(source).toLowerCase();
+      if (ext === '.pdf') {
+        isPdf = true;
+        buffers = [fs.readFileSync(source)];
+      } else {
+        buffers = [fs.readFileSync(source)];
+      }
+    } else {
+      // Buffer
+      isPdf = source[0] === 0x25 && source[1] === 0x50 && source[2] === 0x44 && source[3] === 0x46;
+      buffers = [source];
+    }
+    
+    if (isPdf) {
+      yield* processPdf(engine, buffers[0], options);
+    } else {
+      yield* processImages(engine, buffers, options);
+    }
+  } finally {
+    if (engineCreated) {
+      await engine.close();
+    }
+  }
+}
+
+// Export facade + document capabilities
+module.exports = {
+  ...facade,
+  hasPdfSupport,
+  recognizeDocument
+};