@lexmata/micropdf 0.4.0

package/native/device.cc

@@ -0,0 +1,179 @@
+/**
+ * MicroPDF Device Bindings
+ *
+ * N-API bindings for device operations.
+ * Devices are the destination for rendering operations.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Create a draw device for pixmap rendering
+ *
+ * @param ctx - Context handle
+ * @param pixmap - Pixmap handle
+ * @returns Device handle
+ */
+Napi::BigInt NewDrawDevice(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, pixmap")
+            .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 pixmap_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    uint64_t device_handle = fz_new_draw_device(ctx_handle, pixmap_handle);
+
+    return Napi::BigInt::New(env, device_handle);
+}
+
+/**
+ * Create a display list device
+ *
+ * @param ctx - Context handle
+ * @param list - Display list handle
+ * @returns Device handle
+ */
+Napi::BigInt NewListDevice(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, list")
+            .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 list_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    uint64_t device_handle = fz_new_list_device(ctx_handle, list_handle);
+
+    return Napi::BigInt::New(env, device_handle);
+}
+
+/**
+ * Drop device handle
+ *
+ * @param ctx - Context handle
+ * @param device - Device handle
+ */
+Napi::Value DropDevice(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, device")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t device_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_drop_device(ctx_handle, device_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Close device (finish rendering)
+ *
+ * @param ctx - Context handle
+ * @param device - Device handle
+ */
+Napi::Value CloseDevice(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, device")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t device_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_close_device(ctx_handle, device_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Begin new page on device
+ *
+ * @param ctx - Context handle
+ * @param device - Device handle
+ * @param rect - Page rectangle {x0, y0, x1, y1}
+ */
+Napi::Value DeviceBeginPage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3) {
+        Napi::TypeError::New(env, "Expected 3 arguments: ctx, device, rect")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t device_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    Napi::Object rect_obj = info[2].As<Napi::Object>();
+    fz_rect rect;
+    rect.x0 = rect_obj.Get("x0").As<Napi::Number>().FloatValue();
+    rect.y0 = rect_obj.Get("y0").As<Napi::Number>().FloatValue();
+    rect.x1 = rect_obj.Get("x1").As<Napi::Number>().FloatValue();
+    rect.y1 = rect_obj.Get("y1").As<Napi::Number>().FloatValue();
+
+    fz_begin_page(ctx_handle, device_handle, rect);
+
+    return env.Undefined();
+}
+
+/**
+ * End current page on device
+ *
+ * @param ctx - Context handle
+ * @param device - Device handle
+ */
+Napi::Value DeviceEndPage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, device")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t device_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_end_page(ctx_handle, device_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Initialize Device module exports
+ */
+Napi::Object InitDevice(Napi::Env env, Napi::Object exports) {
+    exports.Set("newDrawDevice", Napi::Function::New(env, NewDrawDevice));
+    exports.Set("newListDevice", Napi::Function::New(env, NewListDevice));
+    exports.Set("dropDevice", Napi::Function::New(env, DropDevice));
+    exports.Set("closeDevice", Napi::Function::New(env, CloseDevice));
+    exports.Set("deviceBeginPage", Napi::Function::New(env, DeviceBeginPage));
+    exports.Set("deviceEndPage", Napi::Function::New(env, DeviceEndPage));
+    
+    return exports;
+}
+
+

package/native/display_list.cc

@@ -0,0 +1,179 @@
+/**
+ * MicroPDF Display List Bindings
+ *
+ * N-API bindings for PDF display list operations.
+ * Display lists cache rendering commands for efficient repeated rendering.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+
+/**
+ * Create a new display list
+ *
+ * @param ctx - Context handle
+ * @param rect - Bounding rectangle {x0, y0, x1, y1}
+ * @returns Display list handle
+ */
+Napi::BigInt NewDisplayList(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, rect")
+            .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::Object rect_obj = info[1].As<Napi::Object>();
+    fz_rect rect;
+    rect.x0 = rect_obj.Get("x0").As<Napi::Number>().FloatValue();
+    rect.y0 = rect_obj.Get("y0").As<Napi::Number>().FloatValue();
+    rect.x1 = rect_obj.Get("x1").As<Napi::Number>().FloatValue();
+    rect.y1 = rect_obj.Get("y1").As<Napi::Number>().FloatValue();
+
+    uint64_t list_handle = fz_new_display_list(ctx_handle, rect);
+
+    return Napi::BigInt::New(env, list_handle);
+}
+
+/**
+ * Drop display list handle
+ *
+ * @param ctx - Context handle
+ * @param list - Display list handle
+ */
+Napi::Value DropDisplayList(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, list")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t list_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_drop_display_list(ctx_handle, list_handle);
+
+    return env.Undefined();
+}
+
+/**
+ * Get display list bounds
+ *
+ * @param ctx - Context handle
+ * @param list - Display list handle
+ * @returns Rectangle {x0, y0, x1, y1}
+ */
+Napi::Object GetDisplayListBounds(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    Napi::Object rect = Napi::Object::New(env);
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, list")
+            .ThrowAsJavaScriptException();
+        return rect;
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t list_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    fz_rect bounds = fz_bound_display_list(ctx_handle, list_handle);
+
+    rect.Set("x0", Napi::Number::New(env, bounds.x0));
+    rect.Set("y0", Napi::Number::New(env, bounds.y0));
+    rect.Set("x1", Napi::Number::New(env, bounds.x1));
+    rect.Set("y1", Napi::Number::New(env, bounds.y1));
+
+    return rect;
+}
+
+/**
+ * Run display list on device
+ *
+ * @param ctx - Context handle
+ * @param list - Display list handle
+ * @param device - Device handle
+ * @param matrix - Transform matrix {a, b, c, d, e, f}
+ * @param rect - Clipping rectangle {x0, y0, x1, y1}
+ */
+Napi::Value RunDisplayList(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 5) {
+        Napi::TypeError::New(env, "Expected 5 arguments: ctx, list, device, matrix, rect")
+            .ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    bool lossless;
+    uint64_t ctx_handle = info[0].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t list_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+    uint64_t device_handle = info[2].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    Napi::Object matrix_obj = info[3].As<Napi::Object>();
+    fz_matrix matrix;
+    matrix.a = matrix_obj.Get("a").As<Napi::Number>().FloatValue();
+    matrix.b = matrix_obj.Get("b").As<Napi::Number>().FloatValue();
+    matrix.c = matrix_obj.Get("c").As<Napi::Number>().FloatValue();
+    matrix.d = matrix_obj.Get("d").As<Napi::Number>().FloatValue();
+    matrix.e = matrix_obj.Get("e").As<Napi::Number>().FloatValue();
+    matrix.f = matrix_obj.Get("f").As<Napi::Number>().FloatValue();
+
+    Napi::Object rect_obj = info[4].As<Napi::Object>();
+    fz_rect rect;
+    rect.x0 = rect_obj.Get("x0").As<Napi::Number>().FloatValue();
+    rect.y0 = rect_obj.Get("y0").As<Napi::Number>().FloatValue();
+    rect.x1 = rect_obj.Get("x1").As<Napi::Number>().FloatValue();
+    rect.y1 = rect_obj.Get("y1").As<Napi::Number>().FloatValue();
+
+    fz_run_display_list(ctx_handle, list_handle, device_handle, matrix, rect);
+
+    return env.Undefined();
+}
+
+/**
+ * Create display list from page
+ *
+ * @param ctx - Context handle
+ * @param page - Page handle
+ * @returns Display list handle
+ */
+Napi::BigInt NewDisplayListFromPage(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2) {
+        Napi::TypeError::New(env, "Expected 2 arguments: ctx, page")
+            .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 page_handle = info[1].As<Napi::BigInt>().Uint64Value(&lossless);
+
+    uint64_t list_handle = fz_new_display_list_from_page(ctx_handle, page_handle);
+
+    return Napi::BigInt::New(env, list_handle);
+}
+
+/**
+ * Initialize DisplayList module exports
+ */
+Napi::Object InitDisplayList(Napi::Env env, Napi::Object exports) {
+    exports.Set("newDisplayList", Napi::Function::New(env, NewDisplayList));
+    exports.Set("dropDisplayList", Napi::Function::New(env, DropDisplayList));
+    exports.Set("getDisplayListBounds", Napi::Function::New(env, GetDisplayListBounds));
+    exports.Set("runDisplayList", Napi::Function::New(env, RunDisplayList));
+    exports.Set("newDisplayListFromPage", Napi::Function::New(env, NewDisplayListFromPage));
+
+    return exports;
+}
+
+

package/native/document.cc

@@ -0,0 +1,268 @@
+/**
+ * Document FFI Bindings
+ *
+ * Implements N-API bindings for PDF document functions.
+ */
+
+#include <napi.h>
+#include "include/mupdf_minimal.h"
+#include <cstring>
+
+/**
+ * Helper: Extract context from object
+ */
+static fz_context GetContext(const Napi::Object& obj) {
+    return obj.Get("_handle").As<Napi::Number>().Int32Value();
+}
+
+/**
+ * Helper: Extract document handle from object
+ */
+static fz_document GetDocument(const Napi::Object& obj) {
+    return obj.Get("_handle").As<Napi::Number>().Int32Value();
+}
+
+/**
+ * Open document from file path
+ * JavaScript: openDocumentFromPath(ctx: NativeContext, path: string): NativeDocument
+ */
+Napi::Value OpenDocumentFromPath(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsString()) {
+        Napi::TypeError::New(env, "Expected (context, path)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    std::string path = info[1].As<Napi::String>().Utf8Value();
+
+    fz_document doc = fz_open_document(ctx, path.c_str());
+    if (doc == 0) {
+        Napi::Error::New(env, "Failed to open document").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("_handle", Napi::Number::New(env, doc));
+    return obj;
+}
+
+/**
+ * Open document from memory buffer
+ * JavaScript: openDocument(ctx: NativeContext, data: Buffer, magic: string): NativeDocument
+ */
+Napi::Value OpenDocument(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsBuffer() || !info[2].IsString()) {
+        Napi::TypeError::New(env, "Expected (context, buffer, magic)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    Napi::Buffer<uint8_t> buffer = info[1].As<Napi::Buffer<uint8_t>>();
+    std::string magic = info[2].As<Napi::String>().Utf8Value();
+
+    fz_document doc = fz_open_document_with_buffer(ctx, magic.c_str(), buffer.Data(), buffer.Length());
+    if (doc == 0) {
+        Napi::Error::New(env, "Failed to open document").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    Napi::Object obj = Napi::Object::New(env);
+    obj.Set("_handle", Napi::Number::New(env, doc));
+    return obj;
+}
+
+/**
+ * Drop/free a document
+ * JavaScript: dropDocument(ctx: NativeContext, doc: NativeDocument): void
+ */
+Napi::Value DropDocument(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, document)").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+
+    fz_drop_document(ctx, doc);
+
+    return env.Undefined();
+}
+
+/**
+ * Count pages in document
+ * JavaScript: countPages(ctx: NativeContext, doc: NativeDocument): number
+ */
+Napi::Value CountPages(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, document)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+
+    int count = fz_count_pages(ctx, doc);
+
+    return Napi::Number::New(env, count);
+}
+
+/**
+ * Check if document needs password
+ * JavaScript: needsPassword(ctx: NativeContext, doc: NativeDocument): boolean
+ */
+Napi::Value NeedsPassword(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 2 || !info[0].IsObject() || !info[1].IsObject()) {
+        Napi::TypeError::New(env, "Expected (context, document)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+
+    int needs = fz_needs_password(ctx, doc);
+
+    return Napi::Boolean::New(env, needs != 0);
+}
+
+/**
+ * Authenticate document with password
+ * JavaScript: authenticatePassword(ctx: NativeContext, doc: NativeDocument, password: string): boolean
+ */
+Napi::Value AuthenticatePassword(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsString()) {
+        Napi::TypeError::New(env, "Expected (context, document, password)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+    std::string password = info[2].As<Napi::String>().Utf8Value();
+
+    int success = fz_authenticate_password(ctx, doc, password.c_str());
+
+    return Napi::Boolean::New(env, success != 0);
+}
+
+/**
+ * Check document permission
+ * JavaScript: hasPermission(ctx: NativeContext, doc: NativeDocument, permission: number): boolean
+ */
+Napi::Value HasPermission(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsNumber()) {
+        Napi::TypeError::New(env, "Expected (context, document, permission)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+    int permission = info[2].As<Napi::Number>().Int32Value();
+
+    int has = fz_has_permission(ctx, doc, permission);
+
+    return Napi::Boolean::New(env, has != 0);
+}
+
+/**
+ * Get document metadata
+ * JavaScript: getMetadata(ctx: NativeContext, doc: NativeDocument, key: string): string | null
+ */
+Napi::Value GetMetadata(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsString()) {
+        Napi::TypeError::New(env, "Expected (context, document, key)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+    std::string key = info[2].As<Napi::String>().Utf8Value();
+
+    char buf[1024] = {0};
+    int len = fz_lookup_metadata(ctx, doc, key.c_str(), buf, sizeof(buf));
+
+    if (len > 0) {
+        return Napi::String::New(env, buf);
+    }
+
+    return env.Null();
+}
+
+/**
+ * Save document to file
+ * JavaScript: saveDocument(ctx: NativeContext, doc: NativeDocument, path: string): void
+ */
+Napi::Value SaveDocument(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsString()) {
+        Napi::TypeError::New(env, "Expected (context, document, path)").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+    std::string path = info[2].As<Napi::String>().Utf8Value();
+
+    pdf_save_document(ctx, doc, path.c_str(), nullptr);
+
+    return env.Undefined();
+}
+
+/**
+ * Resolve named destination
+ * JavaScript: resolveLink(ctx: NativeContext, doc: NativeDocument, name: string): number | null
+ */
+Napi::Value ResolveLink(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 3 || !info[0].IsObject() || !info[1].IsObject() || !info[2].IsString()) {
+        Napi::TypeError::New(env, "Expected (context, document, name)").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    fz_context ctx = GetContext(info[0].As<Napi::Object>());
+    fz_document doc = GetDocument(info[1].As<Napi::Object>());
+    std::string name = info[2].As<Napi::String>().Utf8Value();
+
+    int page = pdf_lookup_named_dest(ctx, doc, name.c_str());
+
+    if (page >= 0) {
+        return Napi::Number::New(env, page);
+    }
+
+    return env.Null();
+}
+
+/**
+ * Initialize document exports
+ */
+Napi::Object InitDocument(Napi::Env env, Napi::Object exports) {
+    exports.Set("openDocumentFromPath", Napi::Function::New(env, OpenDocumentFromPath));
+    exports.Set("openDocument", Napi::Function::New(env, OpenDocument));
+    exports.Set("dropDocument", Napi::Function::New(env, DropDocument));
+    exports.Set("countPages", Napi::Function::New(env, CountPages));
+    exports.Set("needsPassword", Napi::Function::New(env, NeedsPassword));
+    exports.Set("authenticatePassword", Napi::Function::New(env, AuthenticatePassword));
+    exports.Set("hasPermission", Napi::Function::New(env, HasPermission));
+    exports.Set("getMetadata", Napi::Function::New(env, GetMetadata));
+    exports.Set("saveDocument", Napi::Function::New(env, SaveDocument));
+    exports.Set("resolveLink", Napi::Function::New(env, ResolveLink));
+    return exports;
+}
+

package/native/enhanced.cc

@@ -0,0 +1,70 @@
+/**
+ * Enhanced API FFI Bindings
+ *
+ * Implements N-API bindings for MicroPDF-specific enhanced functions.
+ */
+
+#include <napi.h>
+#include "include/micropdf/enhanced.h"
+#include <vector>
+#include <cstring>
+
+/**
+ * Helper: Extract context handle from object
+ */
+static int32_t GetContext(const Napi::Object& obj) {
+    return obj.Get("_handle").As<Napi::Number>().Int32Value();
+}
+
+/**
+ * Merge multiple PDFs into one output PDF
+ * JavaScript: npMergePDFs(ctx: NativeContext, paths: string[], count: number, outputPath: string): number
+ */
+Napi::Value MergePDFs(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+
+    if (info.Length() < 4 ||
+        !info[0].IsObject() ||
+        !info[1].IsArray() ||
+        !info[2].IsNumber() ||
+        !info[3].IsString()) {
+        Napi::TypeError::New(env, "Expected (context, paths: string[], count: number, outputPath: string)")
+            .ThrowAsJavaScriptException();
+        return Napi::Number::New(env, -1);
+    }
+
+    int32_t ctx = GetContext(info[0].As<Napi::Object>());
+    Napi::Array pathsArray = info[1].As<Napi::Array>();
+    int32_t count = info[2].As<Napi::Number>().Int32Value();
+    std::string outputPath = info[3].As<Napi::String>().Utf8Value();
+
+    // Convert JavaScript string array to C string array
+    std::vector<const char*> paths(count);
+    std::vector<std::string> pathStrings(count);
+
+    for (int32_t i = 0; i < count; i++) {
+        Napi::Value val = pathsArray[i];
+        if (!val.IsString()) {
+            Napi::TypeError::New(env, "All paths must be strings")
+                .ThrowAsJavaScriptException();
+            return Napi::Number::New(env, -1);
+        }
+        pathStrings[i] = val.As<Napi::String>().Utf8Value();
+        paths[i] = pathStrings[i].c_str();
+    }
+
+    // Call the Rust FFI function
+    int32_t result = mp_merge_pdfs(ctx, paths.data(), count, outputPath.c_str());
+
+    return Napi::Number::New(env, result);
+}
+
+/**
+ * Initialize enhanced API exports
+ */
+Napi::Object InitEnhanced(Napi::Env env, Napi::Object exports) {
+    exports.Set("npMergePDFs", Napi::Function::New(env, MergePDFs));
+
+    return exports;
+}
+