@reekon-tools/react-native-pdf-canvas 0.1.1 → 0.2.1

package/android/tools/compile-gate.sh

@@ -1,33 +1,30 @@
 #!/bin/bash
 #
-# The Android compile gate: type- and syntax-check every Android source in this
-# package WITHOUT gradle, an emulator, or a device. Runs in seconds.
+# The Android compile gate: build and link every Android source in this package
+# WITHOUT gradle, an emulator, or a device. Runs in seconds.
 #
-# WHY THIS EXISTS. A cold gradle build of a consuming app is ~45 minutes here and
+# WHY THIS EXISTS. A cold gradle build of a consuming app is ~45 minutes and
 # does not reliably produce a runnable app, so the practical alternative to this
-# script is "change JNI and find out on an EAS build". Two of the four things it
-# checks cannot be caught any other way short of a device:
+# script is "change JNI and find out on an EAS build". What it checks:
 #
-#   * src/reactnative/PdfCanvasModule.java is not compiled by the standalone
-#     build at all. Its own header used to say "nothing in this file has ever
-#     been compiled or run"; this is what changed that.
-#   * A JNI signature that drifts from its Java `native` declaration compiles
-#     clean on BOTH sides and fails only as an UnsatisfiedLinkError at runtime.
-#     Section 5 makes javac derive the expected prototypes and has clang compare
-#     them against the definitions, in both directions.
+#   1. The C++ core + JNI compile and LINK into libpdfcanvas.so for arm64 and
+#      armv7, in both configurations (standalone / WITH_JSI), against the pinned
+#      libpdfium.so and — for WITH_JSI — the react-android AAR's own libjsi.so,
+#      with `-Wl,--no-undefined`. A platform function missing at the minSdk, a
+#      PDFium symbol the pinned build does not export, or a jsi symbol the app's
+#      RN version lacks all fail HERE.
+#   2. The built .so exports every JNI symbol Java will look up.
+#   3. javac: the React-free core (`src/main`), the binding (`src/reactnative`,
+#      against the RN classes.jar) and the instrumented suite.
+#   4. JNI SIGNATURES: `javac -h` derives the expected C prototypes from the
+#      `native` declarations; force-including that header makes clang compare
+#      every definition against its declaration, and the reverse check finds a
+#      method declared native with no definition. Both are the class of bug that
+#      compiles clean on both sides and fails only as an UnsatisfiedLinkError.
 #
-# HOW FAR THE C++ HALF GOES. Not a syntax check — it compiles and LINKS the real
-# shared library, in both configurations, with `-Wl,--no-undefined`, against the
-# NDK's own libjnigraphics and the react-android AAR's own libjsi.so. So a missing
-# `target_link_libraries` entry, a platform function that does not exist at the
-# minSdk, or a jsi symbol the app's React Native version does not export all fail
-# HERE. It then checks that the built .so exports every JNI symbol Java expects.
-# What is skipped versus a real build is gradle and cmake orchestration only.
-#
-# WHAT IT IS NOT. It runs no Java, no C++ and no test. Correctness of the
-# rasterizer and of the raster transport is proven by
-# `cd android && ./gradlew connectedDebugAndroidTest` on a device, and nothing
-# here substitutes for that.
+# WHAT IT IS NOT. It runs no Java, no C++ and no test. Rendering correctness is
+# proven by `native/tests` on the host; the JNI seam on a device by
+# `cd android && ./gradlew connectedDebugAndroidTest`.
 #
 # Usage:  bash android/tools/compile-gate.sh
 #
@@ -37,6 +34,7 @@
 set -u
 here=$(cd "$(dirname "$0")/.." && pwd)   # <repo>/android
 PKG=$here
+ROOT=$(cd "$here/.." && pwd)
 fail=0
 skipped=0
 
@@ -55,7 +53,6 @@ SDK=${ANDROID_SDK_ROOT:-${ANDROID_HOME:-$HOME/AppData/Local/Android/Sdk}}
 [ -d "$SDK" ] || SDK=$HOME/Library/Android/sdk
 [ -d "$SDK" ] || SDK=$HOME/Android/Sdk
 
-# Newest installed NDK, unless one is pinned.
 NDK=${ANDROID_NDK_HOME:-}
 if [ -z "$NDK" ]; then
   NDK=$(ls -d "$SDK"/ndk/* 2>/dev/null | sort -V | tail -1)
@@ -68,13 +65,10 @@ for host in windows-x86_64 darwin-x86_64 linux-x86_64; do
   done
 done
 
-# Newest platform android.jar. -bootclasspath needs a Windows-style path on
-# Windows because javac is a native binary; `cygpath -m` is a no-op elsewhere.
 winpath() { if command -v cygpath >/dev/null 2>&1; then cygpath -m "$1"; else echo "$1"; fi; }
 AJAR=$(ls -d "$SDK"/platforms/android-*/android.jar 2>/dev/null | sort -V | tail -1)
 [ -n "$AJAR" ] && AJAR=$(winpath "$AJAR")
 
-# javac 17: the module targets VERSION_17. A JDK 8 javac cannot compile it.
 JAVAC=""
 for cand in "${JAVA_HOME:-}/bin/javac" \
             "/c/Program Files/Android/Android Studio/jbr/bin/javac.exe" \
@@ -84,8 +78,6 @@ for cand in "${JAVA_HOME:-}/bin/javac" \
   [ "${v:-0}" -ge 11 ] 2>/dev/null && JAVAC="$cand" && break
 done
 
-# jsi/jsi.h and the react-android classes.jar come from a consuming app's
-# node_modules. RN_ROOT can point straight at one.
 RN=${RN_ROOT:-}
 if [ -z "$RN" ]; then
   for cand in "$here/../node_modules/react-native" \
@@ -99,11 +91,6 @@ JSI="$RN/ReactCommon/jsi"
 OUT=${TMPDIR:-/tmp}/pdfcanvas-gate
 rm -rf "$OUT"; mkdir -p "$OUT"/{standalone,autolinked,androidtest,h,classes,rn}
 
-# react-android's classes.jar is inside an AAR in the gradle cache. Needed only
-# for section 3.
-# Extracted WHOLE rather than with a `jni/*` member filter: MSYS unzip extracts
-# nothing for that pattern, which silently loses libjsi.so and turns the
-# WITH_JSI link into a skip. The AAR is a couple of megabytes; just unpack it.
 RNJAR=""
 aar=$(ls -t "$HOME"/.gradle/caches/modules-2/files-2.1/com.facebook.react/react-android/*/*/*-release.aar 2>/dev/null | head -1)
 [ -z "$aar" ] && aar=$(ls -t "$HOME"/.gradle/caches/modules-2/files-2.1/com.facebook.react/react-android/*/*/*-debug.aar 2>/dev/null | head -1)
@@ -120,104 +107,107 @@ for host in windows-x86_64 darwin-x86_64 linux-x86_64; do
   done
 done
 
-# libjsi.so ships inside the same AAR, one copy per ABI, already unpacked above.
 JSILIB=""
 [ -f "$OUT/rn/jni/arm64-v8a/libjsi.so" ] && JSILIB="$OUT/rn/jni"
 
-echo "SDK   $SDK"
-echo "NDK   ${NDK:-<none>}"
-echo "javac ${JAVAC:-<none>}"
-echo "RN    ${RN:-<none>}"
+# PDFium for the two ABIs the gate links. Fetched through the same script the
+# build uses, so the gate links exactly what the AAR will carry.
+PDFIUM="$ROOT/native/.pdfium/android"
+if command -v node >/dev/null 2>&1; then
+  (cd "$ROOT" && node scripts/fetch-pdfium.mjs android --abis arm64-v8a,armeabi-v7a >/dev/null) || echo "WARN  fetch-pdfium failed; using whatever is at $PDFIUM"
+fi
+
+CORE_SRCS=$(ls "$ROOT"/native/core/src/*.cpp)
+JNI_SRC="$PKG/src/main/cpp/pdfcanvas-jni.cpp"
+INCLUDES="-I$ROOT/native/core/include -I$PDFIUM/include"
+
+echo "SDK    $SDK"
+echo "NDK    ${NDK:-<none>}"
+echo "javac  ${JAVAC:-<none>}"
+echo "RN     ${RN:-<none>}"
+echo "PDFium $PDFIUM ($(cat "$PDFIUM/.stamp" 2>/dev/null || echo 'not fetched'))"
 echo
 
 # ---------------------------------------------------------------- 1. C++
-# Both #if configurations, both pointer widths. 32-bit is not redundant: it is
-# what catches a size_t/jsize/uint64 width slip that arm64 hides.
 abi_dir() { case "$1" in aarch64*) echo arm64-v8a;; armv7a*) echo armeabi-v7a;; esac; }
 
-if [ -n "$CLANG" ]; then
+if [ -n "$CLANG" ] && [ -f "$PDFIUM/include/fpdfview.h" ]; then
   for abi in aarch64-linux-android24 armv7a-linux-androideabi24; do
+    lib="$PDFIUM/jniLibs/$(abi_dir "$abi")/libpdfium.so"
+    if [ ! -f "$lib" ]; then say_skip "cpp+link $abi" "no libpdfium.so for $(abi_dir "$abi")"; continue; fi
     # --no-undefined is the point of linking rather than syntax-checking: it
-    # fails on any symbol the platform will not supply at runtime, which is
-    # exactly the class of mistake a -fsyntax-only pass waves through and a
-    # device then reports as a dlopen failure and a silent base64 fallback.
+    # fails on any symbol the platform (or PDFium) will not supply at runtime.
     run "cpp+link standalone    $abi" "$CLANG" --target=$abi -std=c++17 -O2 \
-        -Wall -Wextra -Werror -shared -fPIC -o "$OUT/lib-$abi.so" \
-        "$PKG/src/jsi/cpp/pdfcanvas-jsi.cpp" -ljnigraphics -Wl,--no-undefined
+        -Wall -Wextra -Werror -frtti -fexceptions -shared -fPIC $INCLUDES \
+        -o "$OUT/lib-$abi.so" $CORE_SRCS "$JNI_SRC" "$lib" -llog -Wl,--no-undefined
 
     if [ -f "$JSI/jsi/jsi.h" ] && [ -n "$JSILIB" ] && [ -d "$JSILIB/$(abi_dir "$abi")" ]; then
       run "cpp+link WITH_JSI      $abi" "$CLANG" --target=$abi -std=c++17 -O2 \
-          -Wall -Wextra -Werror -frtti -fexceptions -shared -fPIC \
+          -Wall -Wextra -Werror -frtti -fexceptions -shared -fPIC $INCLUDES \
           -DPDFCANVAS_WITH_JSI=1 -I"$JSI" -o "$OUT/lib-jsi-$abi.so" \
-          "$PKG/src/jsi/cpp/pdfcanvas-jsi.cpp" -ljnigraphics \
+          $CORE_SRCS "$JNI_SRC" "$lib" -llog \
           -L"$JSILIB/$(abi_dir "$abi")" -ljsi -Wl,--no-undefined
     elif [ ! -f "$JSI/jsi/jsi.h" ]; then
-      say_skip "cpp+link WITH_JSI      $abi" \
-        "no jsi/jsi.h; set RN_ROOT to a react-native install"
+      say_skip "cpp+link WITH_JSI      $abi" "no jsi/jsi.h; set RN_ROOT to a react-native install"
     else
-      say_skip "cpp+link WITH_JSI      $abi" \
-        "no libjsi.so for this ABI in the react-android AAR"
+      say_skip "cpp+link WITH_JSI      $abi" "no libjsi.so for this ABI in the react-android AAR"
     fi
   done
 
-  # The gate links with an explicit -l list, so it would keep passing if the
-  # equivalent line were dropped from CMakeLists.txt — the real build would then
-  # fail, loudly, but only on a machine running gradle. Assert the two agree.
-  cml="$PKG/src/jsi/cpp/CMakeLists.txt"
+  # The gate links with an explicit list, so it would keep passing if the
+  # equivalent line were dropped from CMakeLists.txt. Assert the two agree.
+  cml="$PKG/src/main/cpp/CMakeLists.txt"
   missing_link=""
-  for lib in jnigraphics; do
+  for lib in pdfium log; do
     grep -q "target_link_libraries.*[ (]$lib[ )]" "$cml" || missing_link="$missing_link $lib"
   done
   if [ -z "$missing_link" ]; then
     echo "PASS  CMakeLists links what this gate links"
   else
-    echo "FAIL  this gate links$missing_link but CMakeLists.txt does not"
-    fail=1
+    echo "FAIL  this gate links$missing_link but CMakeLists.txt does not"; fail=1
   fi
 
-  # The built library must actually EXPORT what Java will look up. A visibility
-  # flag or a namespace slip hides a symbol without failing any compile.
+  # The core source list in pdfcanvas-core.cmake must name every file that
+  # exists, or a platform build silently misses one.
+  for f in $CORE_SRCS; do
+    grep -q "$(basename "$f")" "$ROOT/native/core/pdfcanvas-core.cmake" \
+      || { echo "FAIL  native/core/src/$(basename "$f") is not listed in pdfcanvas-core.cmake"; fail=1; }
+  done
+
   if [ -n "$NM" ] && [ -f "$OUT/lib-aarch64-linux-android24.so" ]; then
     exported=$("$NM" -D --defined-only "$OUT/lib-aarch64-linux-android24.so" 2>/dev/null \
-      | grep -c 'Java_tools_reekon_pdfcanvas')
-    if [ "${exported:-0}" -ge 7 ]; then
-      echo "PASS  the linked .so exports $exported Java_tools_reekon_* symbols"
+      | grep -c 'Java_tools_reekon_pdfcanvas_PdfCanvasNative_')
+    if [ "${exported:-0}" -ge 13 ]; then
+      echo "PASS  the linked .so exports $exported Java_tools_reekon_pdfcanvas_PdfCanvasNative_* symbols"
     else
-      echo "FAIL  the linked .so exports only ${exported:-0} JNI symbols (expected >= 7)"
-      fail=1
+      echo "FAIL  the linked .so exports only ${exported:-0} JNI symbols (expected >= 13)"; fail=1
     fi
   else
     say_skip "exported JNI symbols" "no llvm-nm, or nothing linked"
   fi
-else
+elif [ -z "$CLANG" ]; then
   say_skip "cpp (all)" "no NDK clang++ found; set ANDROID_NDK_HOME"
+else
+  say_skip "cpp (all)" "no PDFium headers at $PDFIUM; run node scripts/fetch-pdfium.mjs android"
 fi
 
-# ---------------------------------------------------------------- 2/3/4. Java
+# ---------------------------------------------------------------- 2/3. Java
 if [ -n "$JAVAC" ] && [ -n "$AJAR" ]; then
-  # Standalone build: main + jsi, no React anywhere, against the strict Android
-  # API surface. -Werror here because this half is meant to stay clean.
-  run "javac standalone (main+jsi)" \
+  run "javac standalone (main)" \
     "$JAVAC" -proc:none -nowarn -Werror -d "$OUT/standalone" -bootclasspath "$AJAR" \
     -source 8 -target 8 \
-    "$PKG"/src/main/java/tools/reekon/pdfcanvas/*.java \
-    "$PKG"/src/jsi/java/tools/reekon/pdfcanvas/jsi/*.java
+    "$PKG"/src/main/java/tools/reekon/pdfcanvas/*.java
 
-  # Autolinked build: adds src/reactnative. Its lambdas need a real java.base,
-  # so android.jar moves from -bootclasspath to -cp.
   if [ -n "$RNJAR" ]; then
     run "javac autolinked (+reactnative)" \
       "$JAVAC" -proc:none -nowarn -d "$OUT/autolinked" -cp "$AJAR;$RNJAR" \
       "$PKG"/src/main/java/tools/reekon/pdfcanvas/*.java \
-      "$PKG"/src/jsi/java/tools/reekon/pdfcanvas/jsi/*.java \
       "$PKG"/src/reactnative/java/tools/reekon/pdfcanvas/rn/*.java
   else
     say_skip "javac autolinked (+reactnative)" \
       "no react-android AAR in the gradle cache; build a consuming app once to populate it"
   fi
 
-  # The instrumented suite, against the standalone classes it tests. Compiling
-  # it is how a change to the rasterizer's API is caught before a device run.
   TESTCP=""
   for a in androidx.test/core androidx.test/monitor androidx.test/runner androidx.test.ext/junit; do
     aa=$(ls -t "$HOME"/.gradle/caches/modules-2/files-2.1/$a/*/*/*.aar 2>/dev/null | head -1)
@@ -241,36 +231,26 @@ else
   say_skip "javac (all)" "need a JDK 11+ javac and an SDK platform android.jar"
 fi
 
-# ---------------------------------------------------------------- 5. JNI
-# THE SECTION THAT EARNS THIS SCRIPT. javac -h derives the expected C prototypes
-# from the Java `native` declarations; force-including that header makes clang
-# compare every definition against its declaration, so a drifted parameter list
-# or return type is a compile error instead of an UnsatisfiedLinkError on a
-# device. The loop then checks the reverse: a method declared `native` in Java
-# with no C++ definition compiles clean everywhere and fails only at runtime.
-if [ -n "$JAVAC" ] && [ -n "$AJAR" ] && [ -n "$CLANG" ] && [ -f "$JSI/jsi/jsi.h" ]; then
+# ---------------------------------------------------------------- 4. JNI
+if [ -n "$JAVAC" ] && [ -n "$AJAR" ] && [ -n "$CLANG" ] && [ -f "$PDFIUM/include/fpdfview.h" ]; then
   if "$JAVAC" -proc:none -nowarn -d "$OUT/classes" -h "$OUT/h" -bootclasspath "$AJAR" \
        -source 8 -target 8 \
-       "$PKG"/src/main/java/tools/reekon/pdfcanvas/*.java \
-       "$PKG"/src/jsi/java/tools/reekon/pdfcanvas/jsi/*.java >/dev/null 2>&1; then
+       "$PKG"/src/main/java/tools/reekon/pdfcanvas/*.java >/dev/null 2>&1; then
     for abi in aarch64-linux-android24 armv7a-linux-androideabi24; do
-      # -fsyntax-only here on purpose: this pass exists to compare declarations,
-      # and the link is already covered by section 1.
+      # -fsyntax-only on purpose: this pass compares declarations; the link is
+      # already covered by section 1.
       run "jni prototypes match   $abi" "$CLANG" --target=$abi -std=c++17 -fsyntax-only \
-          -Wall -Wextra -Werror -frtti -fexceptions -DPDFCANVAS_WITH_JSI=1 -I"$JSI" \
-          -I"$OUT/h" -include tools_reekon_pdfcanvas_jsi_PdfCanvasPixelBridge.h \
-          "$PKG/src/jsi/cpp/pdfcanvas-jsi.cpp"
+          -Wall -Wextra -Werror -frtti -fexceptions $INCLUDES \
+          -I"$OUT/h" -include tools_reekon_pdfcanvas_PdfCanvasNative.h "$JNI_SRC"
     done
     declared=$(grep -o 'Java_[A-Za-z0-9_]*' "$OUT"/h/*.h | sed 's/.*://' | sort -u)
     n=0; missing=""
     for m in $declared; do
       n=$((n + 1))
-      grep -q "^${m}($" "$PKG/src/jsi/cpp/pdfcanvas-jsi.cpp" || missing="$missing $m"
+      grep -q "${m}(" "$JNI_SRC" || missing="$missing $m"
     done
-    # A floor, because an extraction that silently finds nothing would make this
-    # check pass forever while testing nothing.
-    if [ "$n" -lt 7 ]; then
-      echo "FAIL  the JNI gate found only $n declared native methods (expected >= 7)"; fail=1
+    if [ "$n" -lt 13 ]; then
+      echo "FAIL  the JNI gate found only $n declared native methods (expected >= 13)"; fail=1
     elif [ -n "$missing" ]; then
       echo "FAIL  declared native in Java, undefined in C++:$missing"; fail=1
     else
@@ -280,7 +260,7 @@ if [ -n "$JAVAC" ] && [ -n "$AJAR" ] && [ -n "$CLANG" ] && [ -f "$JSI/jsi/jsi.h"
     echo "FAIL  could not generate JNI headers"; fail=1
   fi
 else
-  say_skip "jni signature gate" "needs javac, android.jar, NDK clang++ and jsi/jsi.h together"
+  say_skip "jni signature gate" "needs javac, android.jar, NDK clang++ and the PDFium headers together"
 fi
 
 echo "---"

package/dist/controller.d.ts

@@ -90,6 +90,20 @@ export interface PdfControllerOptions {
      * epoch never spawns a lane it has no work for.
      */
     maxConcurrentRenders?: number;
+    /**
+     * Whether tiles draw the PDF's own annotations — highlights, callouts,
+     * stamps, arrows, AND form fields — into the raster.
+     *
+     * DEFAULT TRUE: a page on the canvas should look like the same page in any
+     * other viewer, which is what the field reports that prompted this were
+     * about ("the annotations are missing"). It used to be hardcoded false on the
+     * theory that the Skia layer draws the app's OWN annotations and a PDF-embedded
+     * copy would double-draw. That theory is only true for a host that IMPORTS
+     * PDF annotations into its own layer — none does today — and such a host is
+     * who this switch is for: set it false and the tiles carry the content stream
+     * alone, on every backend, identically.
+     */
+    annotations?: boolean;
     /** Injected so tests drive a fake clock. Nothing below calls Date.now. */
     now?: () => number;
     /** Injected so tests drive a fake clock. Nothing below calls setTimeout. */

package/dist/controller.js

@@ -95,6 +95,7 @@ function toPdfError(cause) {
 }
 export function createPdfController(options) {
     const { handle, policy, ingest, cache, allowedPages } = options;
+    const drawAnnotations = options.annotations ?? true;
     const now = options.now ?? DEFAULT_NOW;
     const schedule = options.schedule ?? DEFAULT_SCHEDULE;
     const backendId = options.backendId ?? 'unknown';
@@ -417,9 +418,9 @@ export function createPdfController(options) {
                         height: item.docRect.height / info.layoutScale,
                     },
                     scale: item.scale * info.layoutScale,
-                    // Never: the Skia layer draws the app's own annotations on top and
-                    // PDF-embedded ones would double-draw.
-                    annotations: false,
+                    // See `PdfControllerOptions.annotations`: true unless the host
+                    // draws the PDF's annotations itself.
+                    annotations: drawAnnotations,
                     background: 'white',
                 }, state.abort.signal);
             }

package/dist/rasterizer/index.native.d.ts

@@ -1,19 +1,15 @@
 /**
  * The native default rasterizer.
  *
- * BOTH PLATFORMS ARE WIRED. `createAndroidRasterizer` and `createIosRasterizer`
- * are pure and injectable, and this file is the only place a real native module
- * is resolved. On any build where the module is absent — a host that skipped
- * autolinking, a platform neither branch knows — the self-describing placeholder
- * is returned exactly as before, failing at `open()` rather than at import, so
- * the pure core, the Skia ingest path and the fake backend all keep working.
- *
- * ONE NATIVE MODULE NAME FOR BOTH PLATFORMS (`PdfCanvas`), one wire format, and
- * therefore one lookup. What differs is which adapter wraps it, because the
- * capabilities and the alpha encoding differ — see `./native-bridge.ts`.
+ * ONE NATIVE MODULE NAME FOR BOTH PLATFORMS (`PdfCanvas`), one wire format, one
+ * adapter, one engine. `createNativeRasterizer` is pure and injectable, and this
+ * file is the only place a real native module is resolved. On any build where
+ * the module is absent — a host that skipped autolinking, a platform neither
+ * binding knows — the self-describing placeholder is returned, failing at
+ * `open()` rather than at import, so the pure core, the Skia ingest path and the
+ * fake backend all keep working.
  */
 import type { PageRasterizer } from '../types.js';
 export * from './index.js';
-export * from './android.js';
-export * from './ios.js';
+export * from './native.js';
 export declare const getDefaultRasterizer: () => PageRasterizer;

package/dist/rasterizer/index.native.js

@@ -1,27 +1,24 @@
 /**
  * The native default rasterizer.
  *
- * BOTH PLATFORMS ARE WIRED. `createAndroidRasterizer` and `createIosRasterizer`
- * are pure and injectable, and this file is the only place a real native module
- * is resolved. On any build where the module is absent — a host that skipped
- * autolinking, a platform neither branch knows — the self-describing placeholder
- * is returned exactly as before, failing at `open()` rather than at import, so
- * the pure core, the Skia ingest path and the fake backend all keep working.
- *
- * ONE NATIVE MODULE NAME FOR BOTH PLATFORMS (`PdfCanvas`), one wire format, and
- * therefore one lookup. What differs is which adapter wraps it, because the
- * capabilities and the alpha encoding differ — see `./native-bridge.ts`.
+ * ONE NATIVE MODULE NAME FOR BOTH PLATFORMS (`PdfCanvas`), one wire format, one
+ * adapter, one engine. `createNativeRasterizer` is pure and injectable, and this
+ * file is the only place a real native module is resolved. On any build where
+ * the module is absent — a host that skipped autolinking, a platform neither
+ * binding knows — the self-describing placeholder is returned, failing at
+ * `open()` rather than at import, so the pure core, the Skia ingest path and the
+ * fake backend all keep working.
  */
-import { createAndroidRasterizer } from './android.js';
-import { createIosRasterizer } from './ios.js';
+import { createNativeRasterizer } from './native.js';
 import { createMissingBackendRasterizer } from './index.js';
 export * from './index.js';
-export * from './android.js';
-export * from './ios.js';
+export * from './native.js';
 const MISSING = createMissingBackendRasterizer('missing-native', 'The PdfCanvas native module was not found. On iOS that means the pod is ' +
     'not in the build (run `pod install` after adding the package, and check ' +
     'that `PdfCanvas` appears in Podfile.lock); on Android it means ' +
-    'autolinking did not register PdfCanvasPackage.');
+    'autolinking did not register PdfCanvasPackage. Either way the app binary ' +
+    'predates this package or was built without it — an OTA update cannot add ' +
+    'a native module.');
 /**
  * `require`, not `import`, and wrapped in a try.
  *
@@ -59,9 +56,8 @@ function loadNativeModule() {
  * reopen a document, so the default must not be a fresh object per call.
  *
  * IT ALSO NEGOTIATES THE TRANSPORT, which is why "once" matters more than
- * tidiness: `createNativeRasterizer` probes the JSI path at construction, and on
- * iOS that probe is what installs `__pdfCanvasTakePixels` into this runtime. A
- * fresh rasterizer per call would re-run the probe, and each run parks a slot.
+ * tidiness: `createNativeRasterizer` probes the JSI path at construction, and
+ * each run parks a probe slot. A fresh rasterizer per call would re-run it.
  *
  * NAME COLLISION, deliberate and unresolved here: `react/usePdfDocument.ts`
  * exports a registry accessor with this same name and a DIFFERENT meaning
@@ -74,7 +70,5 @@ function loadNativeModule() {
 const resolved = loadNativeModule();
 const DEFAULT = resolved === null
     ? MISSING
-    : resolved.os === 'ios'
-        ? createIosRasterizer(resolved.module)
-        : createAndroidRasterizer(resolved.module);
+    : createNativeRasterizer(resolved.module, { platform: resolved.os });
 export const getDefaultRasterizer = () => DEFAULT;