Multi-format document ecosystem (#42)

* add paperjam-model crate, refactor core to use shared types

* add document format crates: docx, xlsx, pptx, html, epub

* add infra crates: convert, pipeline, cli, mcp, studio

* update python, wasm, and async bindings for ecosystem

* update python API and examples for multi-format support

* update docs: new guides, API docs, and landing page

* update README for ecosystem expansion

* fix(wasm): use pure-Rust compression to avoid libz-sys on wasm32

* fix(tests): update validation level assertions for PDF/A-Xb format

* add 0.2.0 changelog entry for multi-format ecosystem

Author: pratyush618

CHANGELOG.md

@@ -7,6 +7,43 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.0] — 2026-04-04
+
+### Added
+
+- **Multi-format ecosystem**: new crates for DOCX (`paperjam-docx`), XLSX (`paperjam-xlsx`), PPTX (`paperjam-pptx`), HTML (`paperjam-html`), and EPUB (`paperjam-epub`)
+- **Shared model layer**: `paperjam-model` crate with format-agnostic types shared across all crates
+- **Format conversion engine**: `paperjam-convert` crate for converting between document formats
+- **Processing pipelines**: `paperjam-pipeline` crate for YAML-driven multi-step document workflows
+- **CLI tool**: `paperjam-cli` crate with commands for all core operations
+- **MCP server**: `paperjam-mcp` crate exposing document operations over the Model Context Protocol
+- **Studio UI**: `paperjam-studio` — web-based document viewer, converter, and pipeline builder
+- **AnyDocument API**: format-agnostic Python wrapper for non-PDF documents
+- `open()` auto-detects format and returns `Document` (PDF) or `AnyDocument` (other formats)
+- `open_pdf()` for explicit PDF-only usage with strict typing
+- `convert()`, `convert_bytes()`, and `detect_format()` Python functions
+- `Pipeline` Python class for building and running document processing pipelines
+- Async conversion helpers in `paperjam-async`
+- AES-256 encryption support
+- LTV (Long-Term Validation) signature embedding
+- PDF/A conversion (`convert_to_pdf_a`)
+- PDF/UA accessibility validation (`validate_pdf_ua`)
+- WASM bindings for multi-format operations, conversion, and format detection
+
+### Fixed
+
+- WASM: draw black rectangles over redacted text instead of just removing it
+- WASM: serialize `doc_bytes` as `Uint8Array` instead of `Array<number>`
+- WASM: make `owner_password` optional in encrypt binding
+- WASM: cache-bust module URL to prevent stale JS/WASM mismatch
+- WASM: use pure-Rust compression to avoid `libz-sys` failure on `wasm32-unknown-unknown`
+
+### Changed
+
+- Core types (annotations, bookmarks, layout, metadata, etc.) moved from `paperjam-core` to `paperjam-model` and re-exported
+- Validation report `level` field now returns full format string (e.g. `"PDF/A-1b"` instead of `"1b"`)
+- Examples updated to use `open_pdf()` for type-safe PDF operations
+
 ## [0.1.3] — 2026-03-28
 
 ### Fixed

Cargo.toml

@@ -1,10 +1,21 @@
 [workspace]
 resolver = "2"
 members = [
+    "crates/paperjam-model",
     "crates/paperjam-core",
+    "crates/paperjam-cli",
     "crates/paperjam-async",
     "crates/paperjam-py",
     "crates/paperjam-wasm",
+    "crates/paperjam-docx",
+    "crates/paperjam-xlsx",
+    "crates/paperjam-pptx",
+    "crates/paperjam-convert",
+    "crates/paperjam-html",
+    "crates/paperjam-epub",
+    "crates/paperjam-pipeline",
+    "crates/paperjam-mcp",
+    "crates/paperjam-studio",
 ]
 
 [workspace.package]

README.md

@@ -2,63 +2,133 @@
   <img src="docs-site/static/img/logo.jpeg" alt="paperjam logo" width="250">
 </p>
 
+# paperjam
 
-<p align="center">Fast PDF processing powered by Rust.</p>
+[![PyPI](https://img.shields.io/pypi/v/paperjam)](https://pypi.org/project/paperjam/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+
+Fast document processing powered by Rust. One API. Every document format.
+
+## Supported Formats
+
+| Format | Read | Write | Extract Text | Extract Tables | Convert |
+|--------|------|-------|--------------|----------------|---------|
+| PDF    | Yes  | Yes   | Yes          | Yes            | Yes     |
+| DOCX   | Yes  | Yes   | Yes          | Yes            | Yes     |
+| XLSX   | Yes  | Yes   | Yes          | Yes            | Yes     |
+| PPTX   | Yes  | Yes   | Yes          | Yes            | Yes     |
+| HTML   | Yes  | Yes   | Yes          | Yes            | Yes     |
+| EPUB   | Yes  | Yes   | Yes          | -              | Yes     |
 
 ## Installation
 
 ```bash
 pip install paperjam
 ```
 
+CLI tool (Rust):
+
+```bash
+cargo install paperjam-cli
+```
+
 ## Quick Start
 
+### Open any format
+
 ```python
 import paperjam
 
 doc = paperjam.open("report.pdf")
+docx = paperjam.open("document.docx")
+xlsx = paperjam.open("data.xlsx")
+pptx = paperjam.open("slides.pptx")
+```
 
-# Extract text
-text = doc.pages[0].extract_text()
+### Extract text and tables
 
-# Extract tables
-tables = doc.pages[0].extract_tables()
+```python
+doc = paperjam.open("report.pdf")
 
-# Convert to Markdown
+text = doc.pages[0].extract_text()
+tables = doc.pages[0].extract_tables()
 md = doc.to_markdown(layout_aware=True)
+```
+
+### Convert between formats
 
-# Async support
-doc = await paperjam.aopen("report.pdf")
-md = await doc.ato_markdown()
+```python
+paperjam.convert("report.pdf", "report.docx")
+paperjam.convert("data.xlsx", "data.pdf")
+paperjam.convert("page.html", "page.epub")
+```
+
+### Run a pipeline
+
+```yaml
+# pipeline.yaml
+steps:
+  - open: "reports/*.pdf"
+  - extract_tables:
+      strategy: auto
+      output: tables.csv
+  - convert:
+      format: docx
+      output: "converted/"
+```
+
+```bash
+paperjam pipeline run pipeline.yaml
+```
+
+### CLI usage
+
+```bash
+paperjam extract text report.pdf
+paperjam extract tables data.pdf --format csv
+paperjam convert report.pdf report.docx
+paperjam info document.pdf
+```
+
+### MCP server
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "paperjam": {
+      "command": "paperjam",
+      "args": ["mcp", "serve"]
+    }
+  }
+}
 ```
 
 ## Features
 
-- **Text extraction** — plain text, positioned lines, spans with font info
-- **Table extraction** — lattice and stream strategies with CSV/DataFrame export
-- **PDF to Markdown** — layout-aware conversion for LLM/RAG pipelines
-- **Page manipulation** — split, merge, reorder, rotate, delete, insert blank pages
-- **Search** — full-text search across pages with bounding boxes
-- **Metadata & bookmarks** — read and edit document properties and outline
-- **Annotations & watermarks** — add, read, remove annotations; text watermarks
-- **Forms** — inspect, fill, create, and modify form fields
-- **Security** — encryption (AES-128/256, RC4), sanitization, true content-stream redaction
-- **PDF diff** — text-level comparison of two documents
-- **Layout analysis** — multi-column detection, header/footer identification
-- **Native async** — powered by Rust and tokio, no Python thread pools
-- **Digital signatures** — sign, verify, and inspect with LTV timestamp support
-- **PDF/A** — validation and conversion (XMP, ICC profiles, transparency removal)
-- **PDF/UA** — accessibility validation (structure tree, alt text, tagged content)
-- **WASM playground** — try it in the browser at [docs.byteveda.org/paperjam](https://docs.byteveda.org/paperjam/)
+- **Multi-format support** -- PDF, DOCX, XLSX, PPTX, HTML, EPUB through one unified API
+- **Text extraction** -- plain text, positioned lines, spans with font info
+- **Table extraction** -- lattice and stream strategies with CSV/DataFrame export
+- **Format conversion** -- convert between any supported formats
+- **Pipeline engine** -- define multi-step document workflows in YAML
+- **MCP server** -- expose document operations as tools for AI agents
+- **PDF manipulation** -- split, merge, reorder, rotate, delete, insert blank pages
+- **Metadata & bookmarks** -- read and edit document properties and outline
+- **Annotations & watermarks** -- add, read, remove annotations; text watermarks
+- **Forms** -- inspect, fill, create, and modify form fields
+- **Security** -- encryption (AES-128/256, RC4), sanitization, true content-stream redaction
+- **Digital signatures** -- sign, verify, and inspect with LTV timestamp support
+- **PDF/A & PDF/UA** -- validation and conversion, accessibility checks
+- **Native async** -- powered by Rust and tokio, no Python thread pools
+- **CLI tool** -- full-featured command-line interface for scripting and automation
+- **WASM playground** -- try it in the browser at [docs.byteveda.org/paperjam](https://docs.byteveda.org/paperjam/)
 
 ## Documentation
 
 Full docs, API reference, and interactive playground at **[docs.byteveda.org/paperjam](https://docs.byteveda.org/paperjam/)**.
 
-## Changelog
-
-See [CHANGELOG.md](CHANGELOG.md) for a detailed release history.
-
 ## License
 
 MIT

crates/paperjam-async/Cargo.toml

@@ -3,8 +3,14 @@ name = "paperjam-async"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
-description = "Async wrappers for paperjam-core via tokio::spawn_blocking"
+description = "Async wrappers for paperjam operations via tokio::spawn_blocking"
 
 [dependencies]
 paperjam-core = { path = "../paperjam-core", features = ["render", "signatures", "validation"] }
+paperjam-model = { path = "../paperjam-model" }
+paperjam-convert = { path = "../paperjam-convert", optional = true }
 tokio = { workspace = true }
+
+[features]
+default = ["convert"]
+convert = ["dep:paperjam-convert"]

crates/paperjam-async/src/convert.rs

@@ -0,0 +1,39 @@
+use paperjam_model::format::DocumentFormat;
+
+/// Async version of `paperjam_convert::convert_bytes`.
+pub async fn convert_bytes(
+    input: Vec<u8>,
+    from_format: DocumentFormat,
+    to_format: DocumentFormat,
+) -> Result<Vec<u8>, paperjam_convert::ConvertError> {
+    tokio::task::spawn_blocking(move || {
+        paperjam_convert::convert_bytes(&input, from_format, to_format)
+    })
+    .await
+    .unwrap_or_else(|e| Err(paperjam_convert::ConvertError::Extraction(e.to_string())))
+}
+
+/// Async version of `paperjam_convert::convert` (file-to-file).
+pub async fn convert(
+    input_path: String,
+    output_path: String,
+) -> Result<paperjam_convert::ConvertReport, paperjam_convert::ConvertError> {
+    tokio::task::spawn_blocking(move || {
+        paperjam_convert::convert(
+            std::path::Path::new(&input_path),
+            std::path::Path::new(&output_path),
+        )
+    })
+    .await
+    .unwrap_or_else(|e| Err(paperjam_convert::ConvertError::Extraction(e.to_string())))
+}
+
+/// Async extraction to `IntermediateDoc`.
+pub async fn extract(
+    bytes: Vec<u8>,
+    format: DocumentFormat,
+) -> Result<paperjam_convert::IntermediateDoc, paperjam_convert::ConvertError> {
+    tokio::task::spawn_blocking(move || paperjam_convert::extract::extract(&bytes, format))
+        .await
+        .unwrap_or_else(|e| Err(paperjam_convert::ConvertError::Extraction(e.to_string())))
+}

crates/paperjam-async/src/generic.rs

@@ -0,0 +1,73 @@
+use std::sync::Arc;
+
+use paperjam_model::document::DocumentTrait;
+use paperjam_model::metadata::Metadata;
+use paperjam_model::structure::ContentBlock;
+use paperjam_model::table::Table;
+use paperjam_model::text::TextLine;
+
+/// Extract text from any document implementing `DocumentTrait`.
+pub async fn extract_text<D>(doc: Arc<D>) -> Result<String, D::Error>
+where
+    D: DocumentTrait + Send + Sync + 'static,
+    D::Error: Send + 'static,
+{
+    tokio::task::spawn_blocking(move || doc.extract_text())
+        .await
+        .unwrap_or_else(|e| panic!("spawn_blocking panicked: {}", e))
+}
+
+/// Extract text lines from any document implementing `DocumentTrait`.
+pub async fn extract_text_lines<D>(doc: Arc<D>) -> Result<Vec<TextLine>, D::Error>
+where
+    D: DocumentTrait + Send + Sync + 'static,
+    D::Error: Send + 'static,
+{
+    tokio::task::spawn_blocking(move || doc.extract_text_lines())
+        .await
+        .unwrap_or_else(|e| panic!("spawn_blocking panicked: {}", e))
+}
+
+/// Extract tables from any document implementing `DocumentTrait`.
+pub async fn extract_tables<D>(doc: Arc<D>) -> Result<Vec<Table>, D::Error>
+where
+    D: DocumentTrait + Send + Sync + 'static,
+    D::Error: Send + 'static,
+{
+    tokio::task::spawn_blocking(move || doc.extract_tables())
+        .await
+        .unwrap_or_else(|e| panic!("spawn_blocking panicked: {}", e))
+}
+
+/// Extract structure from any document implementing `DocumentTrait`.
+pub async fn extract_structure<D>(doc: Arc<D>) -> Result<Vec<ContentBlock>, D::Error>
+where
+    D: DocumentTrait + Send + Sync + 'static,
+    D::Error: Send + 'static,
+{
+    tokio::task::spawn_blocking(move || doc.extract_structure())
+        .await
+        .unwrap_or_else(|e| panic!("spawn_blocking panicked: {}", e))
+}
+
+/// Extract metadata from any document implementing `DocumentTrait`.
+pub async fn metadata<D>(doc: Arc<D>) -> Result<Metadata, D::Error>
+where
+    D: DocumentTrait + Send + Sync + 'static,
+    D::Error: Send + 'static,
+{
+    tokio::task::spawn_blocking(move || doc.metadata())
+        .await
+        .unwrap_or_else(|e| panic!("spawn_blocking panicked: {}", e))
+}
+
+/// Convert to markdown from any document implementing `DocumentTrait`.
+pub async fn to_markdown<D>(doc: Arc<D>) -> Result<String, D::Error>
+where
+    D: DocumentTrait + Send + Sync + 'static,
+    D::Error: Send + 'static,
+{
+    tokio::task::spawn_blocking(move || doc.to_markdown())
+        .await
+        .unwrap_or_else(|e| panic!("spawn_blocking panicked: {}", e))
+}

crates/paperjam-async/src/lib.rs

@@ -1,6 +1,10 @@
 pub mod document;
+pub mod generic;
 pub mod page;
 
+#[cfg(feature = "convert")]
+pub mod convert;
+
 use paperjam_core::error::PdfError;
 
 /// Convert a tokio JoinError into a PdfError.