ci: validate separated ruled-grid fix

.github/workflows/ci-wasm.yml

@@ -113,7 +113,13 @@ jobs:
           path: packages/wasm/pkg/
 
       - name: Install Miniflare
-        run: npm install miniflare@latest
+        # Pinned, NOT @latest: miniflare@latest currently resolves to a 5.x
+        # alpha whose `new Miniflare()` options schema replaced the 4.x
+        # single-worker form (`modules: [...]`) used by
+        # scripts/edge-compat/wasm-test.mjs with a nested `workers: [...]`
+        # shape. There is no root package.json/lockfile in this repo, so the
+        # version has to live here. Bump deliberately, re-running the test.
+        run: npm install --no-save miniflare@4.20260730.0
 
       - name: Run edge runtime parse test
         run: node scripts/edge-compat/wasm-test.mjs

.gitignore

@@ -45,6 +45,7 @@ temp/
 !integration_tests_data/receipt.png
 !integration_tests_data/sample3.docx.doc
 !integration_tests_data/sample.pdf
+!integration_tests_data/filled_acroform.pdf
 deno.json
 
 # Python files

README.md

@@ -137,6 +137,8 @@ npx skills add run-llama/llamaparse-agent-skills --skill liteparse
 
 Or copy-pasting the [`SKILL.md`](https://github.com/run-llama/llamaparse-agent-skills/blob/main/skills/liteparse/SKILL.md) file to your own skills setup.
 
+See the [Agent Skill guide](https://developers.llamaindex.ai/liteparse/guides/agent-skill/?utm_source=github&utm_medium=liteparse) for requirements and usage patterns.
+
 ## CLI Usage
 
 The CLI is the same across all installations (`npm`, `pip`, `cargo install`).
@@ -257,7 +259,18 @@ link annotations. The field is absent by default; enabled untagged pages contain
 
 Parse results (Rust/Node/Python APIs) carry the document's `/Info` `creator`
 and `producer` entries when present; these are API-only and never appear in
-CLI JSON output. Enable `--extract-content-bounds` (Rust/Python
+CLI JSON output. Enable `extract_document_metadata` (JavaScript/WASM
+`extractDocumentMetadata`) to add `doc_meta`/`docMeta`, a provenance object
+with the `/Info` creation/modification dates, PDF version and encryption
+permissions, signature state, incremental-save markers, trailer ID comparison,
+the document catalog's XMP packet (capped at 64 KiB, with `xmp_truncated`
+when it was cut), and source file size. It is off by default because it
+streams the whole source file once; it is absent for inputs converted from a
+non-PDF format, where the facts would describe the intermediate PDF rather
+than your file. `xmp` needs a structural parse of the document, so it is
+skipped (left absent) for sources over 16 MiB and in WASM builds — the other
+fields are unaffected.
+Enable `--extract-content-bounds` (Rust/Python
 `extract_content_bounds`, JavaScript/WASM `extractContentBounds`) to add a
 per-page `content_bounds`: the union bbox of the page's top-level content
 objects in viewport coords (absent for empty pages). Enable

crates/liteparse-napi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "liteparse-napi"
-version = "2.10.1"
+version = "2.12.0"
 edition.workspace = true
 license.workspace = true
 repository.workspace = true
@@ -14,11 +14,11 @@ default = ["tesseract"]
 tesseract = ["liteparse/tesseract"]
 
 [dependencies]
-liteparse = { package = "liteparse", version = "2.10.1", path = "../liteparse", default-features = false }
-pdfium-sys = { package = "liteparse-pdfium-sys", version = "1.4.0", path = "../pdfium-sys" }
+liteparse = { package = "liteparse", version = "2.12.0", path = "../liteparse", default-features = false }
+pdfium-sys = { package = "liteparse-pdfium-sys", version = "1.5.0", path = "../pdfium-sys" }
 napi = { version = "2", features = ["async", "serde-json", "napi9"] }
 napi-derive = "2"
-pdfium = { package = "liteparse-pdfium", version = "1.4.0", path = "../pdfium" }
+pdfium = { package = "liteparse-pdfium", version = "1.5.0", path = "../pdfium" }
 image = { version = "0.25", default-features = false, features = ["png"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

crates/liteparse-napi/src/lib.rs

@@ -4,8 +4,8 @@ use napi_derive::napi;
 mod types;
 
 use types::{
-    JsLiteParseConfig, JsPageComplexityStats, JsPageInput, JsParseResult, JsScreenshotResult,
-    JsTextItem,
+    JsLiteParseConfig, JsPageComplexityStats, JsPageInput, JsParseBatch, JsParseResult,
+    JsScreenshotResult, JsTextItem,
 };
 
 /// Main LiteParse parser class.
@@ -48,6 +48,43 @@ impl LiteParse {
         Ok(JsParseResult::from_rust(&result, &self.config))
     }
 
+    /// Open a document for bounded-memory batch parsing. Internal plumbing
+    /// for the JS wrapper's `parseBatches()` — prefer that; it also closes
+    /// the session for you.
+    ///
+    /// Converts a non-PDF source once, then yields `batchSize` pages at a time
+    /// via `nextBatch()` (default 25). Cross-page passes (repeated
+    /// header/footer removal, image deduplication) see only the pages in their
+    /// own batch, so output can differ from a whole-document `parse()`.
+    #[napi]
+    pub async fn open_batch_session(
+        &self,
+        input: Either<String, Buffer>,
+        batch_size: Option<u32>,
+    ) -> Result<ParseSession> {
+        use liteparse::types::PdfInput;
+
+        let pdf_input = match input {
+            Either::A(path) => PdfInput::Path(path),
+            Either::B(buf) => PdfInput::Bytes(buf.to_vec()),
+        };
+        let batch_size = batch_size
+            .map(|v| v as usize)
+            .unwrap_or(liteparse::DEFAULT_PAGE_BATCH_SIZE);
+
+        let session = self
+            .inner
+            .open_batch_session(pdf_input, batch_size)
+            .await
+            .map_err(|e| Error::from_reason(e.to_string()))?;
+
+        Ok(ParseSession {
+            total_pages: session.total_pages(),
+            inner: std::sync::Arc::new(tokio::sync::Mutex::new(Some(session))),
+            config: self.config.clone(),
+        })
+    }
+
     /// Parse from pre-extracted pages, skipping PDFium text extraction.
     ///
     /// The caller supplies pages already populated with text items in viewport
@@ -134,6 +171,67 @@ impl LiteParse {
     }
 }
 
+/// A document opened once and parsed in bounded page batches. Internal
+/// plumbing for the JS wrapper's `parseBatches()` — prefer that.
+///
+/// Created by `LiteParse.openBatchSession()`. The converted-PDF temporary
+/// file for a non-PDF source lives as long as the session, so conversion is
+/// paid once no matter how many batches are consumed. Call `close()` when
+/// abandoning the session early — otherwise that temp file waits for GC.
+#[napi]
+pub struct ParseSession {
+    /// The core session is `&mut` per batch, but napi hands out `&self`, so
+    /// the mutation is serialized here. Concurrent `nextBatch()` calls queue
+    /// rather than interleave, which also keeps batch order well-defined.
+    /// `None` after `close()`.
+    inner: std::sync::Arc<tokio::sync::Mutex<Option<liteparse::ParseSession>>>,
+    config: liteparse::config::LiteParseConfig,
+    total_pages: u32,
+}
+
+#[napi]
+impl ParseSession {
+    /// Total pages in the source document, before `maxPages` or batching.
+    #[napi(getter)]
+    pub fn total_pages(&self) -> u32 {
+        self.total_pages
+    }
+
+    /// Parse and return the next batch, or `null` once every page within
+    /// `maxPages` has been yielded. Rejects if the session is closed.
+    #[napi]
+    pub async fn next_batch(&self) -> Result<Option<JsParseBatch>> {
+        let inner = self.inner.clone();
+        let mut session = inner.lock().await;
+        let batch = session
+            .as_mut()
+            .ok_or_else(|| Error::from_reason("session is closed"))?
+            .next_batch()
+            .await
+            .map_err(|e| Error::from_reason(e.to_string()))?;
+
+        Ok(batch.map(|batch| JsParseBatch {
+            start_page: batch.start_page,
+            end_page: batch.end_page,
+            result: JsParseResult::from_rust(&batch.result, &self.config),
+        }))
+    }
+
+    /// Release the session's resources now — most importantly the converted
+    /// temporary PDF for a non-PDF source, which otherwise lives until the
+    /// JS object is garbage collected. Idempotent; `nextBatch()` rejects
+    /// afterwards.
+    #[napi]
+    pub async fn close(&self) -> Result<()> {
+        let inner = self.inner.clone();
+        let mut session = inner.lock().await;
+        // Dropping the core session drops the conversion guard, which
+        // removes the temp file.
+        session.take();
+        Ok(())
+    }
+}
+
 /// Search text items for phrase matches, returning merged items with combined bounding boxes.
 #[napi]
 pub fn search_items(