pdf-oxide-wasm 0.3.50 → 0.3.52

package/web/pdf_oxide.js

@@ -2546,7 +2546,9 @@ export class WasmHeader {
 if (Symbol.dispose) WasmHeader.prototype[Symbol.dispose] = WasmHeader.prototype.free;
 
 /**
- * OCR configuration for WebAssembly.
+ * OCR configuration for WebAssembly. (Currently a marker — the engine
+ * uses tuned defaults; knobs are exposed as the WASM OCR surface
+ * matures, #524.)
  */
 export class WasmOcrConfig {
     __destroy_into_raw() {
@@ -2572,7 +2574,17 @@ export class WasmOcrConfig {
 if (Symbol.dispose) WasmOcrConfig.prototype[Symbol.dispose] = WasmOcrConfig.prototype.free;
 
 /**
- * OCR engine for WebAssembly.
+ * OCR engine for WebAssembly (#524).
+ *
+ * OCR runs entirely in-WASM via the pure-Rust `tract` backend — no
+ * native ONNX Runtime, no JS bridge. Model **delivery is host-side**:
+ * the browser/Deno/edge host fetches the detector + recognizer ONNX
+ * files and the char dictionary (see `modelManifest()` for the URLs)
+ * — typically `fetch()` + the Cache API / IndexedDB for the
+ * tens-of-MB models — then hands the bytes to the constructor. This
+ * only works in the `wasm-ocr` build of `pdf-oxide`; the default
+ * `pdf-oxide-wasm` has no OCR (the constructor returns an error
+ * explaining this).
  */
 export class WasmOcrEngine {
     __destroy_into_raw() {
@@ -2586,20 +2598,22 @@ export class WasmOcrEngine {
         wasm.__wbg_wasmocrengine_free(ptr, 0);
     }
     /**
-     * Create a new OCR engine.
-     * @param {string} _det_model_path
-     * @param {string} _rec_model_path
-     * @param {string} _dict_path
+     * Not available in this build. OCR needs the `wasm-ocr` build of
+     * `pdf-oxide` (the pure-Rust tract backend); the default
+     * `pdf-oxide-wasm` ships without it.
+     * @param {Uint8Array} _det_model
+     * @param {Uint8Array} _rec_model
+     * @param {string} _dict
      * @param {WasmOcrConfig | null} [_config]
      */
-    constructor(_det_model_path, _rec_model_path, _dict_path, _config) {
+    constructor(_det_model, _rec_model, _dict, _config) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(_det_model_path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(_det_model, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(_rec_model_path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr1 = passArray8ToWasm0(_rec_model, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passStringToWasm0(_dict_path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr2 = passStringToWasm0(_dict, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len2 = WASM_VECTOR_LEN;
             let ptr3 = 0;
             if (!isLikeNone(_config)) {
@@ -3127,6 +3141,64 @@ export class WasmPdfDocument {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Cheap per-page text-vs-OCR classification → JSON
+     * `DocumentClassification`.
+     * @returns {string}
+     */
+    classifyDocument() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmpdfdocument_classifyDocument(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Cheap per-page classification → JSON `PageClassification`.
+     * @param {number} page_index
+     * @returns {string}
+     */
+    classifyPage(page_index) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmpdfdocument_classifyPage(retptr, this.__wbg_ptr, page_index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Clear all pending erase operations for a page.
      * @param {number} page_index
@@ -3555,6 +3627,40 @@ export class WasmPdfDocument {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Rich per-page extraction → JSON `PageExtraction` (per-region
+     * bbox + typed reason). `optionsJson` is `{}`-tolerant
+     * `AutoExtractOptions`; undefined/empty → defaults.
+     * @param {number} page_index
+     * @param {string | null} [options_json]
+     * @returns {string}
+     */
+    extractPageAuto(page_index, options_json) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            var ptr0 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len0 = WASM_VECTOR_LEN;
+            wasm.wasmpdfdocument_extractPageAuto(retptr, this.__wbg_ptr, page_index, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * Extract complete page text data in a single call.
      *
@@ -3756,6 +3862,36 @@ export class WasmPdfDocument {
             wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * One-shot auto text extraction — graceful native fallback (never
+     * the opaque OCR error #513).
+     * @param {number} page_index
+     * @returns {string}
+     */
+    extractTextAuto(page_index) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmpdfdocument_extractTextAuto(retptr, this.__wbg_ptr, page_index);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
     /**
      * Extract text lines from a page.
      *
@@ -3782,41 +3918,35 @@ export class WasmPdfDocument {
         }
     }
     /**
-     * Extract text using OCR (optical character recognition).
-     *
-     * NOTE: OCR is not yet supported in the WebAssembly build due to missing
-     * ONNX Runtime support for the web backend in the current implementation.
+     * Extract text using OCR. Not available in this build — OCR needs
+     * the `wasm-ocr` build of `pdf-oxide`.
      * @param {number} _page_index
-     * @param {WasmOcrEngine | null} [_engine]
+     * @param {WasmOcrEngine} _engine
      * @returns {string}
      */
     extractTextOcr(_page_index, _engine) {
-        let deferred3_0;
-        let deferred3_1;
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            let ptr0 = 0;
-            if (!isLikeNone(_engine)) {
-                _assertClass(_engine, WasmOcrEngine);
-                ptr0 = _engine.__destroy_into_raw();
-            }
-            wasm.wasmpdfdocument_extractTextOcr(retptr, this.__wbg_ptr, _page_index, ptr0);
+            _assertClass(_engine, WasmOcrEngine);
+            wasm.wasmpdfdocument_extractTextOcr(retptr, this.__wbg_ptr, _page_index, _engine.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
             var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
-            var ptr2 = r0;
-            var len2 = r1;
+            var ptr1 = r0;
+            var len1 = r1;
             if (r3) {
-                ptr2 = 0; len2 = 0;
+                ptr1 = 0; len1 = 0;
                 throw takeObject(r2);
             }
-            deferred3_0 = ptr2;
-            deferred3_1 = len2;
-            return getStringFromWasm0(ptr2, len2);
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
     /**
@@ -5575,6 +5705,10 @@ export class WasmPdfPageRegion {
     }
     /**
      * Extract text using OCR from this region.
+     *
+     * Region-scoped OCR is not wired yet; use the page-level
+     * `WasmPdfDocument.extractTextOcr(pageIndex, engine)` for now
+     * (#524 follow-up).
      * @param {WasmOcrEngine | null} [_engine]
      * @returns {string}
      */
@@ -6155,6 +6289,36 @@ export function hasDocumentTimestamp(pdf_data) {
     return ret !== 0;
 }
 
+/**
+ * #519: Air-gapped OCR model manifest — JSON (detector + every
+ * supported language's cache filenames and source URLs).
+ *
+ * WASM provisioning is **host-side**: browser/WASM has no filesystem
+ * or network-to-disk, so a download-to-cache prefetch cannot run
+ * here. This manifest is informational — it lets the JS host learn
+ * which model files/URLs to fetch and bundle (or ship out of band)
+ * before driving OCR. There is intentionally no `prefetchModels` in
+ * the WASM surface (see `prefetchAvailable`, which always returns
+ * `false`).
+ * @returns {string}
+ */
+export function modelManifest() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.modelManifest(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Plan a bookmark split without producing PDFs. Returns a JSON array
  * of segment objects (`index, startPage…` shape from
@@ -6186,6 +6350,17 @@ export function planSplitByBookmarks(src_bytes, title_prefix, ignore_case, level
     }
 }
 
+/**
+ * #519: Whether this build can download OCR models to a local cache.
+ * Always `false` in WASM — provisioning is host-side (see
+ * `modelManifest`).
+ * @returns {boolean}
+ */
+export function prefetchAvailable() {
+    const ret = wasm.prefetchAvailable();
+    return ret !== 0;
+}
+
 /**
  * Install the process-wide runtime crypto policy from its grammar
  * string (`"compat"|"strict"|"fips-strict"[;…]`). Fail-closed:

package/web/pdf_oxide_bg.wasm.d.ts

@@ -23,7 +23,9 @@ export const cryptoPolicy: (a: number) => void;
 export const generateBarcodeSvg: (a: number, b: number, c: number, d: number) => void;
 export const generateQrSvg: (a: number, b: number, c: number, d: number, e: number) => void;
 export const hasDocumentTimestamp: (a: number, b: number) => number;
+export const modelManifest: (a: number) => void;
 export const planSplitByBookmarks: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+export const prefetchAvailable: () => number;
 export const setCryptoPolicy: (a: number, b: number, c: number) => void;
 export const setLogLevel: (a: number, b: number, c: number) => void;
 export const signPdfBytes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
@@ -158,6 +160,8 @@ export const wasmpdfdocument_applyAllRedactions: (a: number, b: number) => void;
 export const wasmpdfdocument_applyPageRedactions: (a: number, b: number, c: number) => void;
 export const wasmpdfdocument_applyRedactionsDestructive: (a: number, b: number, c: number) => void;
 export const wasmpdfdocument_authenticate: (a: number, b: number, c: number, d: number) => void;
+export const wasmpdfdocument_classifyDocument: (a: number, b: number) => void;
+export const wasmpdfdocument_classifyPage: (a: number, b: number, c: number) => void;
 export const wasmpdfdocument_clearEraseRegions: (a: number, b: number, c: number) => void;
 export const wasmpdfdocument_convertToPdfA: (a: number, b: number, c: number, d: number) => void;
 export const wasmpdfdocument_cropMargins: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -177,6 +181,7 @@ export const wasmpdfdocument_extractChars: (a: number, b: number, c: number, d:
 export const wasmpdfdocument_extractImageBytes: (a: number, b: number, c: number) => void;
 export const wasmpdfdocument_extractImages: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wasmpdfdocument_extractLines: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wasmpdfdocument_extractPageAuto: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wasmpdfdocument_extractPageText: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wasmpdfdocument_extractPages: (a: number, b: number, c: number, d: number) => void;
 export const wasmpdfdocument_extractPaths: (a: number, b: number, c: number, d: number, e: number) => void;
@@ -184,6 +189,7 @@ export const wasmpdfdocument_extractRects: (a: number, b: number, c: number, d:
 export const wasmpdfdocument_extractSpans: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const wasmpdfdocument_extractTables: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wasmpdfdocument_extractText: (a: number, b: number, c: number, d: number) => void;
+export const wasmpdfdocument_extractTextAuto: (a: number, b: number, c: number) => void;
 export const wasmpdfdocument_extractTextLines: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wasmpdfdocument_extractTextOcr: (a: number, b: number, c: number, d: number) => void;
 export const wasmpdfdocument_extractWords: (a: number, b: number, c: number, d: number, e: number) => void;