@build-qube/papyra-native-wasm32-wasi 0.0.3

package/papyra.wasi.d.cts

@@ -0,0 +1,58 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+export declare class PdfDocument {
+  /** Load a PDF from raw bytes. */
+  static load(data: Uint8Array): PdfDocument
+  /** Load an encrypted PDF. */
+  static loadWithPassword(data: Uint8Array, password: string): PdfDocument
+  get pageCount(): number
+  pageSize(index: number): PageDimensions
+  /** Render one page on the calling thread. Blocks; prefer `renderPageAsync`. */
+  renderPage(index: number, dpi?: number | undefined | null): RenderedPage
+  /** Render one page off the JS thread. Several of these run concurrently. */
+  renderPageAsync(index: number, dpi?: number | undefined | null): Promise<RenderedPage>
+  /** Render `[start, end)` in one async task, parallelised internally with rayon. */
+  renderPagesAsync(start: number, end: number, dpi?: number | undefined | null): Promise<Array<RenderedPage>>
+}
+
+/** Name of the rendering backend, currently always `"hayro"`. */
+export declare function backendName(): string
+
+/**
+ * Size the rayon pool used by `renderPagesAsync`.
+ *
+ * Required on wasm: `available_parallelism()` is unsupported there, so rayon otherwise
+ * pins itself to a single thread. Must be called before any other rayon use — the
+ * global pool can only be built once.
+ */
+export declare function configureThreadPool(threads: number, stackSizeMb?: number | undefined | null): number
+
+export interface PageDimensions {
+  /** Width in PDF points (1/72 inch). */
+  width: number
+  /** Height in PDF points (1/72 inch). */
+  height: number
+}
+
+export interface RenderedPage {
+  width: number
+  height: number
+  stride: number
+  /** Always `"rgba8"` for the hayro backend. */
+  format: string
+  data: Uint8Array
+}
+
+/**
+ * Grow the wasm heap up front, from the calling (single) thread.
+ *
+ * Linear memory grows via `memory.grow`; several render workers hitting that on a cold
+ * heap traps intermittently with "memory access out of bounds" (~14% of cold runs at 23
+ * pages / 150 DPI / 8-way). Growing once, single-threaded, makes later allocations come
+ * from the free list. Called automatically on first load; call it explicitly only to
+ * raise the reservation before rendering something unusually large. No-op on native.
+ */
+export declare function reserveMemory(megabytes: number): number
+
+/** `"native"` or `"wasm"`. The wrapper uses this to pick a concurrency strategy. */
+export declare function runtime(): string

package/wasi-worker-browser.mjs

@@ -0,0 +1,45 @@
+import {
+  instantiateNapiModuleSync,
+  MessageHandler,
+  WASI,
+  emnapiAsyncWorkPlugin,
+  emnapiTSFNPlugin,
+} from '@napi-rs/wasm-runtime'
+
+const handler = new MessageHandler({
+  onLoad({ wasmModule, wasmMemory }) {
+    const wasi = new WASI({
+      print: function () {
+        // eslint-disable-next-line no-console
+        console.log.apply(console, arguments)
+      },
+      printErr: function() {
+        // eslint-disable-next-line no-console
+        console.error.apply(console, arguments)
+        
+      },
+    })
+    return instantiateNapiModuleSync(wasmModule, {
+      childThread: true,
+      wasi,
+      // The wasm links a "basic" emnapi archive (no C async-work /
+      // threadsafe-function implementations), so every thread that
+      // instantiates it must provide the JavaScript implementations
+      // through the emnapi plugins.
+      plugins: [emnapiAsyncWorkPlugin, emnapiTSFNPlugin],
+      overwriteImports(importObject) {
+        importObject.env = {
+          ...importObject.env,
+          ...importObject.napi,
+          ...importObject.emnapi,
+          memory: wasmMemory,
+        }
+      },
+    })
+  },
+  
+})
+
+globalThis.onmessage = function (e) {
+  handler.handle(e)
+}

package/wasi-worker.mjs

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import { parse } from "node:path";
+import { WASI } from "node:wasi";
+import { parentPort, Worker } from "node:worker_threads";
+
+const require = createRequire(import.meta.url);
+
+const {
+  instantiateNapiModuleSync,
+  MessageHandler,
+  getDefaultContext,
+  emnapiAsyncWorkPlugin,
+  emnapiTSFNPlugin,
+} = require("@napi-rs/wasm-runtime");
+
+if (parentPort) {
+  parentPort.on("message", (data) => {
+    globalThis.onmessage({ data });
+  });
+}
+
+Object.assign(globalThis, {
+  self: globalThis,
+  require,
+  Worker,
+  importScripts: function (f) {
+    ;(0, eval)(fs.readFileSync(f, "utf8") + "//# sourceURL=" + f);
+  },
+  postMessage: function (msg) {
+    if (parentPort) {
+      parentPort.postMessage(msg);
+    }
+  },
+});
+
+const emnapiContext = getDefaultContext();
+
+const __rootDir = parse(process.cwd()).root;
+
+const handler = new MessageHandler({
+  onLoad({ wasmModule, wasmMemory }) {
+    const wasi = new WASI({
+      version: 'preview1',
+      env: process.env,
+      preopens: {
+        [__rootDir]: __rootDir,
+      },
+    });
+
+    return instantiateNapiModuleSync(wasmModule, {
+      childThread: true,
+      wasi,
+      context: emnapiContext,
+      // The wasm links a "basic" emnapi archive (no C async-work /
+      // threadsafe-function implementations), so every thread that
+      // instantiates it must provide the JavaScript implementations
+      // through the emnapi plugins.
+      plugins: [emnapiAsyncWorkPlugin, emnapiTSFNPlugin],
+      overwriteImports(importObject) {
+        importObject.env = {
+          ...importObject.env,
+          ...importObject.napi,
+          ...importObject.emnapi,
+          memory: wasmMemory
+        };
+      },
+    });
+  },
+});
+
+globalThis.onmessage = function (e) {
+  handler.handle(e);
+};