perf(web): zero-copy pixel path + consolidate js/wasmJs into webMain

Write pdfium's pixel ArrayBuffer straight into Skia's wasm linear memory
(via Data.makeUninitialized + Int8Array.set on awaitSkiko's memory buffer,
pattern from coil3.decode.WebWorker), removing the intermediate Kotlin
ByteArray + installPixels copy. One memcpy on the main thread instead of
two.

Also consolidate the js + wasmJs sources into a shared webMain:

- PdfDocument, PdfiumGlue externals, ClipEntryText, and the Skiko
  zero-copy helper all live in webMain
- jsMain/wasmJsMain reduced to a ~30-line PlatformBridge covering the
  three structural differences between the targets: typed-array to
  Kotlin primitive conversion (zero-cost unsafeCast on js vs bulk copy
  on wasmJs), the kotlinx.coroutines.await signature mismatch (papered
  over by an awaitTyped<T>() expect/actual), and Skiko's platform-
  specific awaitSkiko
- pdfium js target switched to useEsModules() so a single @jsmodule
  annotation works for both targets without a jsMain-only @JsNonModule

Author: kdroidFilter

pdfium/build.gradle.kts

@@ -101,6 +101,10 @@ kotlin {
     jvm()
 
     js {
+        // ES-module output so a single `@file:JsModule("./pdfium_glue.mjs")` declaration
+        // (shared with wasmJs in webMain) works without a jsMain-only `@JsNonModule`
+        // companion annotation.
+        useEsModules()
         browser {
             // Karma pulls from github.com and fails SSL on some hosts; we run no JS tests.
             testTask { enabled = false }

pdfium/src/jsMain/kotlin/dev/nucleusframework/pdfium/PdfDocument.js.kt

@@ -0,0 +1,30 @@
+@file:OptIn(ExperimentalWasmJsInterop::class)
+
+package dev.nucleusframework.pdfium
+
+import kotlin.js.ExperimentalWasmJsInterop
+import kotlin.js.JsAny
+import kotlin.js.Promise
+import kotlinx.coroutines.await
+import org.khronos.webgl.ArrayBuffer
+import org.khronos.webgl.Float32Array
+import org.khronos.webgl.Int32Array
+import org.khronos.webgl.Int8Array
+
+// FloatArray ⇄ Float32Array, IntArray ⇄ Int32Array and ByteArray ⇄ Int8Array share
+// runtime representation on Kotlin/JS (IR) — reinterpret directly, no copy.
+
+internal actual fun ByteArray.toJsArrayBuffer(): ArrayBuffer =
+    this.unsafeCast<Int8Array>().buffer
+
+internal actual fun Float32Array.toSharedFloatArray(): FloatArray =
+    this.unsafeCast<FloatArray>()
+
+internal actual fun Int32Array.toSharedIntArray(): IntArray =
+    this.unsafeCast<IntArray>()
+
+internal actual suspend fun <T : JsAny> Promise<JsAny?>.awaitTyped(): T =
+    this.await().unsafeCast<T>()
+
+internal actual suspend fun awaitSkiko(): JsAny =
+    org.jetbrains.skiko.wasm.awaitSkiko.await()

pdfium/src/jsMain/kotlin/dev/nucleusframework/pdfium/PdfiumGlue.kt

@@ -0,0 +1,30 @@
+package dev.nucleusframework.pdfium
+
+import kotlin.js.JsAny
+import kotlin.js.Promise
+import kotlinx.coroutines.await
+import org.khronos.webgl.ArrayBuffer
+import org.khronos.webgl.Float32Array
+import org.khronos.webgl.Int32Array
+import org.khronos.webgl.toFloatArray
+import org.khronos.webgl.toInt8Array
+import org.khronos.webgl.toIntArray
+
+// Kotlin/Wasm owns its own linear memory, separate from the JS engine heap where typed
+// arrays live — every conversion here is an unavoidable bulk copy.
+
+internal actual fun ByteArray.toJsArrayBuffer(): ArrayBuffer =
+    this.toInt8Array().buffer
+
+internal actual fun Float32Array.toSharedFloatArray(): FloatArray =
+    this.toFloatArray()
+
+internal actual fun Int32Array.toSharedIntArray(): IntArray =
+    this.toIntArray()
+
+internal actual suspend fun <T : JsAny> Promise<JsAny?>.awaitTyped(): T =
+    this.await()
+
+@Suppress("INVISIBLE_REFERENCE")
+internal actual suspend fun awaitSkiko(): JsAny =
+    org.jetbrains.skiko.wasm.awaitSkiko.await()

pdfium/src/jsMain/kotlin/dev/nucleusframework/pdfium/PlatformBridge.js.kt

@@ -1,35 +1,33 @@
+@file:OptIn(ExperimentalWasmJsInterop::class)
+
 package dev.nucleusframework.pdfium
 
 import androidx.compose.ui.graphics.ImageBitmap
 import androidx.compose.ui.graphics.asComposeImageBitmap
-import kotlinx.coroutines.await
+import kotlin.js.ExperimentalWasmJsInterop
 import org.jetbrains.skia.Bitmap
 import org.jetbrains.skia.ColorAlphaType
+import org.jetbrains.skia.Image
 import org.jetbrains.skia.ImageInfo
-import org.khronos.webgl.Int8Array
-import org.khronos.webgl.toByteArray
-import org.khronos.webgl.toFloatArray
-import org.khronos.webgl.toInt8Array
-import org.khronos.webgl.toIntArray
 
 /**
- * wasmJs PDF document. pdfium.wasm runs inside a dedicated Web Worker (spawned by
- * `pdfium_glue.mjs`) so the browser's main thread stays free to paint frames while a
- * render is in flight. Everything here is just a thin [await] bridge from Kotlin
- * suspension onto the RPC promises the worker returns.
+ * Shared web (js + wasmJs) `PdfDocument` actual. pdfium.wasm runs inside a dedicated
+ * Web Worker (spawned by `pdfium_glue.mjs`) so the browser's main thread stays free to
+ * paint frames while a render is in flight. Everything here is just a thin
+ * [awaitTyped] bridge from Kotlin suspension onto the RPC promises the worker returns.
  *
- * The only unavoidable main-thread copy happens inside [renderPage]: the worker's
- * pixel `ArrayBuffer` arrives transferred (zero-copy), then we bulk-copy once into a
- * Kotlin [ByteArray] for Skiko's `installPixels` (Skia has its own wasm heap and
- * exposes no ArrayBuffer-direct install on this Skiko version).
+ * Rendered pixel buffers arrive as transferred [org.khronos.webgl.ArrayBuffer]s and are
+ * written straight into Skia's wasm linear memory via [passToSkiko] — no intermediate
+ * Kotlin [ByteArray]. Platform-specific typed-array bridges live in
+ * [WebTypedArrayBridge].
  */
 internal actual class PdfDocument internal constructor(
     private val docPtr: Int,
     actual val pageCount: Int,
     actual val metadata: PdfMetadata,
 ) {
     actual suspend fun pageSize(pageIndex: Int): PageSize {
-        val r = pageSize(docPtr, pageIndex).await<PageSizeResult>()
+        val r = pageSize(docPtr, pageIndex).awaitTyped<PageSizeResult>()
         return PageSize(r.widthPoints, r.heightPoints)
     }
 
@@ -39,26 +37,24 @@ internal actual class PdfDocument internal constructor(
         heightPx: Int,
         quality: RenderQuality,
     ): ImageBitmap {
-        val r = renderPage(docPtr, pageIndex, widthPx, heightPx, quality.toFlags()).await<RenderResult>()
+        val r = renderPage(docPtr, pageIndex, widthPx, heightPx, quality.toFlags()).awaitTyped<RenderResult>()
         // pdfium writes BGRA, matching Skia's native N32 colour type on wasm — no swizzle.
-        val pixels = Int8Array(r.pixels).toByteArray()
+        val skikoData = r.pixels.passToSkiko()
         val info = ImageInfo.makeN32(widthPx, heightPx, ColorAlphaType.PREMUL)
-        val bitmap = Bitmap()
-        val installed = bitmap.installPixels(info, pixels, widthPx * 4)
-        check(installed) { "Skia installPixels returned false" }
-        return bitmap.asComposeImageBitmap()
+        val image = Image.makeRaster(info, skikoData, widthPx * 4)
+        return Bitmap.makeFromImage(image).asComposeImageBitmap()
     }
 
     actual suspend fun pageText(pageIndex: Int): String =
-        pageText(docPtr, pageIndex).await<TextResult>().text
+        pageText(docPtr, pageIndex).awaitTyped<TextResult>().text
 
     actual suspend fun pageTextLayout(pageIndex: Int): PageTextLayout {
-        val r = pageTextLayout(docPtr, pageIndex).await<TextLayoutResult>()
+        val r = pageTextLayout(docPtr, pageIndex).awaitTyped<TextLayoutResult>()
         val size = PageSize(r.widthPoints, r.heightPoints)
-        val rectBoxes = r.rectBoxes.toFloatArray()
+        val rectBoxes = r.rectBoxes.toSharedFloatArray()
         val rectTexts = Array(r.rectTexts.length) { i -> r.rectTexts[i]?.toString().orEmpty() }
-        val charCodepoints = r.charCodepoints.toIntArray()
-        val charBoxes = r.charBoxes.toFloatArray()
+        val charCodepoints = r.charCodepoints.toSharedIntArray()
+        val charBoxes = r.charBoxes.toSharedFloatArray()
         return PageTextLayout(pageIndex, size, rectBoxes, rectTexts, charCodepoints, charBoxes)
     }
 
@@ -78,10 +74,11 @@ internal actual class PdfDocument internal constructor(
 }
 
 internal actual suspend fun openPdfDocument(bytes: ByteArray, password: String?): PdfDocument {
-    // Move the PDF bytes into a JS ArrayBuffer (bulk copy) and transfer ownership to
-    // the worker — the main thread has no further use for them.
-    val buffer = bytes.toInt8Array().buffer
-    val r = openDocument(buffer, password).await<OpenResult>()
+    // On wasmJs this is a bulk copy into a JS ArrayBuffer, on jsMain it's a zero-copy
+    // reinterpretation (ByteArray IS Int8Array). Either way we transfer ownership to
+    // the worker — the main thread has no further use for the bytes.
+    val buffer = bytes.toJsArrayBuffer()
+    val r = openDocument(buffer, password).awaitTyped<OpenResult>()
     return PdfDocument(
         docPtr = r.doc,
         pageCount = r.pageCount,

pdfium/src/wasmJsMain/kotlin/dev/nucleusframework/pdfium/ClipEntryText.wasmJs.kt

@@ -1,24 +1,23 @@
 @file:JsModule("./pdfium_glue.mjs")
+@file:OptIn(ExperimentalWasmJsInterop::class)
 
 package dev.nucleusframework.pdfium
 
+import kotlin.js.ExperimentalWasmJsInterop
+import kotlin.js.JsAny
+import kotlin.js.JsArray
+import kotlin.js.JsString
 import kotlin.js.Promise
 import org.khronos.webgl.ArrayBuffer
 import org.khronos.webgl.Float32Array
 import org.khronos.webgl.Int32Array
 
 /**
- * External bindings to `pdfium_glue.mjs`. Every call goes over a Web Worker boundary —
- * the JS side returns a [Promise] that resolves once the worker posts back its result.
- * Typed arrays (`Float32Array`, `Int32Array`) and the pixel `ArrayBuffer` are moved via
- * `postMessage` transferables, so they reach the main thread without a structured-clone
- * copy. Handles (document / page pointers) are plain [Int]s into the worker's pdfium
- * heap; the main thread never dereferences them.
- *
- * The `Promise<JsAny?>` return type matches the shape expected by
- * `kotlinx.coroutines.await`'s signature on wasmJs (which is declared as
- * `Promise<JsAny?>.await(): T`); the actual fulfilment values implement the typed
- * result interfaces below and are cast at call sites.
+ * External bindings to `pdfium_glue.mjs`. Shared between jsMain and wasmJsMain via the
+ * `webMain` source set — all interfaces extend [JsAny] so the declarations are valid on
+ * both platforms. The RPC functions uniformly return `Promise<JsAny?>` because
+ * `kotlinx.coroutines.await` on wasmJs is declared on that receiver type; call sites go
+ * through [awaitTyped] to recover the typed fulfilment value.
  */
 internal external interface OpenResult : JsAny {
     val doc: Int