@lexmata/micropdf 0.4.0

package/native/geometry.cc

@@ -0,0 +1,255 @@
+/**
+ * MicroPDF Geometry Bindings
+ *
+ * Node.js bindings for MicroPDF geometry operations.
+ */
+
+#include <napi.h>
+#include "include/micropdf.h"
+
+/**
+ * Create a Point object from micropdf_point_t
+ */
+Napi::Object PointToObject(Napi::Env env, micropdf_point_t p) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("x", Napi::Number::New(env, p.x));
+    obj.Set("y", Napi::Number::New(env, p.y));
+    return obj;
+}
+
+/**
+ * Create micropdf_point_t from a JS object
+ */
+micropdf_point_t ObjectToPoint(Napi::Object obj) {
+    micropdf_point_t p;
+    p.x = obj.Get("x").As<Napi::Number>().FloatValue();
+    p.y = obj.Get("y").As<Napi::Number>().FloatValue();
+    return p;
+}
+
+/**
+ * Create a Rect object from micropdf_rect_t
+ */
+Napi::Object RectToObject(Napi::Env env, micropdf_rect_t r) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("x0", Napi::Number::New(env, r.x0));
+    obj.Set("y0", Napi::Number::New(env, r.y0));
+    obj.Set("x1", Napi::Number::New(env, r.x1));
+    obj.Set("y1", Napi::Number::New(env, r.y1));
+    return obj;
+}
+
+/**
+ * Create micropdf_rect_t from a JS object
+ */
+micropdf_rect_t ObjectToRect(Napi::Object obj) {
+    micropdf_rect_t r;
+    r.x0 = obj.Get("x0").As<Napi::Number>().FloatValue();
+    r.y0 = obj.Get("y0").As<Napi::Number>().FloatValue();
+    r.x1 = obj.Get("x1").As<Napi::Number>().FloatValue();
+    r.y1 = obj.Get("y1").As<Napi::Number>().FloatValue();
+    return r;
+}
+
+/**
+ * Create a Matrix object from micropdf_matrix_t
+ */
+Napi::Object MatrixToObject(Napi::Env env, micropdf_matrix_t m) {
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("a", Napi::Number::New(env, m.a));
+    obj.Set("b", Napi::Number::New(env, m.b));
+    obj.Set("c", Napi::Number::New(env, m.c));
+    obj.Set("d", Napi::Number::New(env, m.d));
+    obj.Set("e", Napi::Number::New(env, m.e));
+    obj.Set("f", Napi::Number::New(env, m.f));
+    return obj;
+}
+
+/**
+ * Create micropdf_matrix_t from a JS object
+ */
+micropdf_matrix_t ObjectToMatrix(Napi::Object obj) {
+    micropdf_matrix_t m;
+    m.a = obj.Get("a").As<Napi::Number>().FloatValue();
+    m.b = obj.Get("b").As<Napi::Number>().FloatValue();
+    m.c = obj.Get("c").As<Napi::Number>().FloatValue();
+    m.d = obj.Get("d").As<Napi::Number>().FloatValue();
+    m.e = obj.Get("e").As<Napi::Number>().FloatValue();
+    m.f = obj.Get("f").As<Napi::Number>().FloatValue();
+    return m;
+}
+
+// Point functions
+Napi::Value CreatePoint(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    float x = 0, y = 0;
+    if (info.Length() >= 2) {
+        x = info[0].As<Napi::Number>().FloatValue();
+        y = info[1].As<Napi::Number>().FloatValue();
+    }
+
+    micropdf_point_t p = {x, y};
+    return PointToObject(env, p);
+}
+
+Napi::Value TransformPoint(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (point, matrix)").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    micropdf_point_t p = ObjectToPoint(info[0].As<Napi::Object>());
+    micropdf_matrix_t m = ObjectToMatrix(info[1].As<Napi::Object>());
+    micropdf_point_t result = micropdf_point_transform(p, m);
+
+    return PointToObject(env, result);
+}
+
+// Rect functions
+Napi::Value CreateRect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    float x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+    if (info.Length() >= 4) {
+        x0 = info[0].As<Napi::Number>().FloatValue();
+        y0 = info[1].As<Napi::Number>().FloatValue();
+        x1 = info[2].As<Napi::Number>().FloatValue();
+        y1 = info[3].As<Napi::Number>().FloatValue();
+    }
+
+    micropdf_rect_t r = {x0, y0, x1, y1};
+    return RectToObject(env, r);
+}
+
+Napi::Value RectEmpty(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return RectToObject(env, micropdf_rect_empty());
+}
+
+Napi::Value RectUnit(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return RectToObject(env, micropdf_rect_unit());
+}
+
+Napi::Value IsRectEmpty(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 1 || !info[0].IsObject()) {
+        Napi::TypeError::New(env, "Expected rect object").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    micropdf_rect_t r = ObjectToRect(info[0].As<Napi::Object>());
+    return Napi::Boolean::New(env, micropdf_rect_is_empty(r) != 0);
+}
+
+Napi::Value RectUnion(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (rect, rect)").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    micropdf_rect_t a = ObjectToRect(info[0].As<Napi::Object>());
+    micropdf_rect_t b = ObjectToRect(info[1].As<Napi::Object>());
+
+    return RectToObject(env, micropdf_rect_union(a, b));
+}
+
+Napi::Value RectIntersect(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (rect, rect)").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    micropdf_rect_t a = ObjectToRect(info[0].As<Napi::Object>());
+    micropdf_rect_t b = ObjectToRect(info[1].As<Napi::Object>());
+
+    return RectToObject(env, micropdf_rect_intersect(a, b));
+}
+
+// Matrix functions
+Napi::Value MatrixIdentity(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    return MatrixToObject(env, micropdf_matrix_identity());
+}
+
+Napi::Value MatrixTranslate(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    float tx = 0, ty = 0;
+    if (info.Length() >= 2) {
+        tx = info[0].As<Napi::Number>().FloatValue();
+        ty = info[1].As<Napi::Number>().FloatValue();
+    }
+
+    return MatrixToObject(env, micropdf_matrix_translate(tx, ty));
+}
+
+Napi::Value MatrixScale(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    float sx = 1, sy = 1;
+    if (info.Length() >= 2) {
+        sx = info[0].As<Napi::Number>().FloatValue();
+        sy = info[1].As<Napi::Number>().FloatValue();
+    }
+
+    return MatrixToObject(env, micropdf_matrix_scale(sx, sy));
+}
+
+Napi::Value MatrixRotate(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    float degrees = 0;
+    if (info.Length() >= 1) {
+        degrees = info[0].As<Napi::Number>().FloatValue();
+    }
+
+    return MatrixToObject(env, micropdf_matrix_rotate(degrees));
+}
+
+Napi::Value MatrixConcat(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (matrix, matrix)").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    micropdf_matrix_t a = ObjectToMatrix(info[0].As<Napi::Object>());
+    micropdf_matrix_t b = ObjectToMatrix(info[1].As<Napi::Object>());
+
+    return MatrixToObject(env, micropdf_matrix_concat(a, b));
+}
+
+// Export initialization function
+Napi::Object InitGeometry(Napi::Env env, Napi::Object exports) {
+    // Point
+    exports.Set("createPoint", Napi::Function::New(env, CreatePoint));
+    exports.Set("transformPoint", Napi::Function::New(env, TransformPoint));
+
+    // Rect
+    exports.Set("createRect", Napi::Function::New(env, CreateRect));
+    exports.Set("rectEmpty", Napi::Function::New(env, RectEmpty));
+    exports.Set("rectUnit", Napi::Function::New(env, RectUnit));
+    exports.Set("isRectEmpty", Napi::Function::New(env, IsRectEmpty));
+    exports.Set("rectUnion", Napi::Function::New(env, RectUnion));
+    exports.Set("rectIntersect", Napi::Function::New(env, RectIntersect));
+
+    // Matrix
+    exports.Set("matrixIdentity", Napi::Function::New(env, MatrixIdentity));
+    exports.Set("matrixTranslate", Napi::Function::New(env, MatrixTranslate));
+    exports.Set("matrixScale", Napi::Function::New(env, MatrixScale));
+    exports.Set("matrixRotate", Napi::Function::New(env, MatrixRotate));
+    exports.Set("matrixConcat", Napi::Function::New(env, MatrixConcat));
+
+    return exports;
+}
+

package/native/image.cc

@@ -0,0 +1,216 @@
+/**
+ * MicroPDF Image Bindings
+ *
+ * N-API bindings for image operations.
+ * Images represent raster graphics with various formats and compression.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Load image from file
+ *
+ * @param ctx - Context handle
+ * @param filename - Path to image file
+ * @returns Image handle
+ */
+Napi::BigInt NewImageFromFile(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, filename")
+            .ThrowAsJavaScriptException();
+        return Napi::BigInt::New(env, static_cast<uint64_t>(0));
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    std::string filename = info[1].As<Napi::String>().Utf8Value();
+
+    uint64_t image_handle = fz_new_image_from_file(ctx_handle, filename.c_str());
+
+    return Napi::BigInt::New(env, image_handle);
+}
+
+/**
+ * Load image from buffer
+ *
+ * @param ctx - Context handle
+ * @param data - Buffer containing image data
+ * @returns Image handle
+ */
+Napi::BigInt NewImageFromBuffer(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, data")
+            .ThrowAsJavaScriptException();
+        return Napi::BigInt::New(env, static_cast<uint64_t>(0));
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    Napi::Buffer<uint8_t> buffer = info[1].As<Napi::Buffer<uint8_t>>();
+
+    uint64_t image_handle = fz_new_image_from_buffer_data(
+        ctx_handle,
+        buffer.Data(),
+        buffer.Length()
+    );
+
+    return Napi::BigInt::New(env, image_handle);
+}
+
+/**
+ * Drop image handle
+ *
+ * @param ctx - Context handle
+ * @param image - Image handle
+ */
+Napi::Value DropImage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, image")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t image_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_drop_image(ctx_handle, image_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Get image width
+ *
+ * @param ctx - Context handle
+ * @param image - Image handle
+ * @returns Width in pixels
+ */
+Napi::Number ImageWidth(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, image")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t image_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t width = fz_image_width(ctx_handle, image_handle);
+
+    return Napi::Number::New(env, width);
+}
+
+/**
+ * Get image height
+ *
+ * @param ctx - Context handle
+ * @param image - Image handle
+ * @returns Height in pixels
+ */
+Napi::Number ImageHeight(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, image")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, 0);
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t image_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t height = fz_image_height(ctx_handle, image_handle);
+
+    return Napi::Number::New(env, height);
+}
+
+/**
+ * Get image colorspace
+ *
+ * @param ctx - Context handle
+ * @param image - Image handle
+ * @returns Colorspace handle
+ */
+Napi::BigInt ImageColorspace(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, image")
+            .ThrowAsJavaScriptException();
+        return Napi::BigInt::New(env, static_cast<uint64_t>(0));
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t image_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    uint64_t cs_handle = fz_image_colorspace(ctx_handle, image_handle);
+
+    return Napi::BigInt::New(env, cs_handle);
+}
+
+/**
+ * Convert image to pixmap
+ *
+ * @param ctx - Context handle
+ * @param image - Image handle
+ * @returns Object {pixmap: BigInt, width: Number, height: Number}
+ */
+Napi::Object GetPixmapFromImage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Object result = Napi::Object::New(env);
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, image")
+            .ThrowAsJavaScriptException();
+        return result;
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t image_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    int32_t w = 0, h = 0;
+    uint64_t pixmap_handle = fz_get_pixmap_from_image(
+        ctx_handle,
+        image_handle,
+        nullptr,
+        nullptr,
+        &w,
+        &h
+    );
+
+    result.Set("pixmap", Napi::BigInt::New(env, pixmap_handle));
+    result.Set("width", Napi::Number::New(env, w));
+    result.Set("height", Napi::Number::New(env, h));
+
+    return result;
+}
+
+/**
+ * Initialize Image module exports
+ */
+Napi::Object InitImage(Napi::Env env, Napi::Object exports) {
+    exports.Set("newImageFromFile", Napi::Function::New(env, NewImageFromFile));
+    exports.Set("newImageFromBuffer", Napi::Function::New(env, NewImageFromBuffer));
+    exports.Set("dropImage", Napi::Function::New(env, DropImage));
+    exports.Set("imageWidth", Napi::Function::New(env, ImageWidth));
+    exports.Set("imageHeight", Napi::Function::New(env, ImageHeight));
+    exports.Set("imageColorspace", Napi::Function::New(env, ImageColorspace));
+    exports.Set("getPixmapFromImage", Napi::Function::New(env, GetPixmapFromImage));
+
+    return exports;
+}
+

package/native/include/micropdf/enhanced.h

@@ -0,0 +1,38 @@
+// MicroPDF - Enhanced/Extended Functions
+// Auto-generated from Rust FFI - DO NOT EDIT MANUALLY
+// Module: enhanced
+//
+// These are MicroPDF-specific extensions beyond MuPDF compatibility.
+// All functions are prefixed with mp_* to distinguish from MuPDF functions.
+
+#ifndef MICROPDF_ENHANCED_H
+#define MICROPDF_ENHANCED_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ============================================================================
+// Enhanced Functions (10 total)
+// ============================================================================
+
+int32_t mp_add_blank_page(int32_t _ctx, int32_t _doc, float width, float height);
+int32_t mp_add_watermark(int32_t _ctx, const char * input_path, const char * output_path, const char * text, float _x, float _y, float font_size, float opacity);
+int32_t mp_draw_circle(int32_t _ctx, int32_t _page, float _x, float _y, float radius, float r, float g, float b, float alpha, int32_t _fill);
+int32_t mp_draw_line(int32_t _ctx, int32_t _page, float _x0, float _y0, float _x1, float _y1, float r, float g, float b, float alpha, float line_width);
+int32_t mp_draw_rectangle(int32_t _ctx, int32_t _page, float _x, float _y, float width, float height, float r, float g, float b, float alpha, int32_t _fill);
+int32_t mp_linearize_pdf(int32_t _ctx, const char * input_path, const char * output_path);
+int32_t mp_merge_pdfs(int32_t _ctx, const char * const * paths, int32_t count, const char * output_path);
+int32_t mp_optimize_pdf(int32_t _ctx, const char * path);
+int32_t mp_split_pdf(int32_t _ctx, const char * input_path, const char * output_dir);
+int32_t mp_write_pdf(int32_t _ctx, int32_t _doc, const char * _path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MICROPDF_ENHANCED_H */

package/native/include/micropdf/types.h

@@ -0,0 +1,36 @@
+/**
+ * MicroPDF Type Definitions
+ *
+ * Type aliases for C/C++ compatibility with Rust-generated headers
+ */
+
+#ifndef MICROPDF_TYPES_H
+#define MICROPDF_TYPES_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Rust type aliases for C/C++
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+typedef size_t usize;
+typedef float f32;
+typedef double f64;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MICROPDF_TYPES_H */
+

package/native/include/micropdf.h

@@ -0,0 +1,106 @@
+/**
+ * MicroPDF - Fast, lightweight PDF library
+ *
+ * This is a comprehensive C FFI header for the MicroPDF Rust library.
+ * All functions are prefixed with fz_ or pdf_ for compatibility with MuPDF.
+ *
+ * This header includes all auto-generated module headers with complete
+ * function declarations for all 660+ FFI functions.
+ *
+ * Usage:
+ *   #include <micropdf.h>
+ *
+ * For MuPDF drop-in compatibility:
+ *   #include <mupdf.h>
+ */
+
+#ifndef MICROPDF_H
+#define MICROPDF_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ============================================================================
+// Type Definitions - Opaque handles for resource management
+// ============================================================================
+
+typedef int32_t fz_context;
+typedef int32_t fz_document;
+typedef int32_t fz_page;
+typedef int32_t fz_device;
+typedef int32_t fz_pixmap;
+typedef int32_t fz_buffer;
+typedef int32_t fz_stream;
+typedef int32_t fz_output;
+typedef int32_t fz_colorspace;
+typedef int32_t fz_font;
+typedef int32_t fz_image;
+typedef int32_t fz_path;
+typedef int32_t fz_text;
+typedef int32_t fz_cookie;
+typedef int32_t fz_display_list;
+typedef int32_t fz_link;
+typedef int32_t fz_archive;
+typedef int32_t pdf_obj;
+typedef int32_t pdf_annot;
+typedef int32_t pdf_form_field;
+
+// ============================================================================
+// Geometry types (used by many modules)
+// ============================================================================
+
+typedef struct {
+    float x, y;
+} fz_point;
+
+typedef struct {
+    float x0, y0;
+    float x1, y1;
+} fz_rect;
+
+typedef struct {
+    int x0, y0;
+    int x1, y1;
+} fz_irect;
+
+typedef struct {
+    float a, b, c, d, e, f;
+} fz_matrix;
+
+typedef struct {
+    fz_point ul, ur, ll, lr;
+} fz_quad;
+
+// ============================================================================
+// Common type aliases
+// ============================================================================
+
+typedef int32_t PdfObjHandle;
+typedef int32_t Handle;
+
+// ============================================================================
+// Function Declarations
+// ============================================================================
+
+/*
+ * All function declarations are auto-generated from Rust FFI source.
+ * See individual module headers in mupdf/fitz/ and mupdf/pdf/ for details.
+ *
+ * Total: 660+ functions covering:
+ * - Core fitz functions (geometry, buffers, streams, devices, etc.)
+ * - PDF-specific functions (annotations, forms, objects, etc.)
+ */
+
+// For complete function declarations, include the comprehensive header:
+#include "mupdf.h"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MICROPDF_H */

package/native/include/mupdf-ffi.h

@@ -0,0 +1,39 @@
+/**
+ * MuPDF FFI Compatibility Header
+ *
+ * This header provides 100% MuPDF-compatible FFI bindings.
+ * Include this for drop-in compatibility with MuPDF-based applications.
+ *
+ * All 660+ fz_* and pdf_* functions are available through this header.
+ *
+ * Usage:
+ *   #include <mupdf-ffi.h>
+ *
+ * Or for complete MuPDF compatibility:
+ *   #include <mupdf.h>
+ */
+
+#ifndef MUPDF_FFI_H
+#define MUPDF_FFI_H
+
+#include "micropdf.h"
+
+/*
+ * All MuPDF-compatible functions are available through micropdf.h
+ *
+ * Function categories:
+ * - Context management (fz_new_context, fz_drop_context, etc.)
+ * - Document operations (fz_open_document, fz_load_page, etc.)
+ * - Geometry operations (fz_concat, fz_transform_rect, etc.)
+ * - Buffer operations (fz_new_buffer, fz_append_data, etc.)
+ * - Device operations (fz_new_bbox_device, fz_fill_path, etc.)
+ * - Image operations (fz_new_image_from_pixmap, fz_decode_image, etc.)
+ * - Text operations (fz_new_text, fz_show_string, etc.)
+ * - PDF object operations (pdf_new_dict, pdf_dict_get, etc.)
+ * - PDF annotation operations (pdf_create_annot, pdf_set_annot_contents, etc.)
+ * - PDF form operations (pdf_next_widget, pdf_set_field_value, etc.)
+ *
+ * Total coverage: 660+ functions
+ */
+
+#endif /* MUPDF_FFI_H */

package/native/include/mupdf.h

@@ -0,0 +1,11 @@
+// MicroPDF - MuPDF API Compatible C Header
+// Single include header for all MuPDF functionality
+
+#ifndef MUPDF_H
+#define MUPDF_H
+
+#include "micropdf/types.h"
+#include "mupdf/fitz.h"
+#include "mupdf/pdf.h"
+
+#endif /* MUPDF_H */